1 /*
2 **
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"
19 //#define LOG_NDEBUG 0
20 #include <utils/Log.h>
21
22 #include <stdint.h>
23 #include <sys/types.h>
24
25 #include <binder/IPCThreadState.h>
26 #include <binder/Parcel.h>
27 #include <media/AudioSanitizer.h>
28 #include <mediautils/ServiceUtilities.h>
29 #include <mediautils/TimeCheck.h>
30 #include "IAudioFlinger.h"
31
32 namespace android {
33
34 enum {
35 CREATE_TRACK = IBinder::FIRST_CALL_TRANSACTION,
36 CREATE_RECORD,
37 SAMPLE_RATE,
38 RESERVED, // obsolete, was CHANNEL_COUNT
39 FORMAT,
40 FRAME_COUNT,
41 LATENCY,
42 SET_MASTER_VOLUME,
43 SET_MASTER_MUTE,
44 MASTER_VOLUME,
45 MASTER_MUTE,
46 SET_STREAM_VOLUME,
47 SET_STREAM_MUTE,
48 STREAM_VOLUME,
49 STREAM_MUTE,
50 SET_MODE,
51 SET_MIC_MUTE,
52 GET_MIC_MUTE,
53 SET_RECORD_SILENCED,
54 SET_PARAMETERS,
55 GET_PARAMETERS,
56 REGISTER_CLIENT,
57 GET_INPUTBUFFERSIZE,
58 OPEN_OUTPUT,
59 OPEN_DUPLICATE_OUTPUT,
60 CLOSE_OUTPUT,
61 SUSPEND_OUTPUT,
62 RESTORE_OUTPUT,
63 OPEN_INPUT,
64 CLOSE_INPUT,
65 INVALIDATE_STREAM,
66 SET_VOICE_VOLUME,
67 GET_RENDER_POSITION,
68 GET_INPUT_FRAMES_LOST,
69 NEW_AUDIO_UNIQUE_ID,
70 ACQUIRE_AUDIO_SESSION_ID,
71 RELEASE_AUDIO_SESSION_ID,
72 QUERY_NUM_EFFECTS,
73 QUERY_EFFECT,
74 GET_EFFECT_DESCRIPTOR,
75 CREATE_EFFECT,
76 MOVE_EFFECTS,
77 LOAD_HW_MODULE,
78 GET_PRIMARY_OUTPUT_SAMPLING_RATE,
79 GET_PRIMARY_OUTPUT_FRAME_COUNT,
80 SET_LOW_RAM_DEVICE,
81 LIST_AUDIO_PORTS,
82 GET_AUDIO_PORT,
83 CREATE_AUDIO_PATCH,
84 RELEASE_AUDIO_PATCH,
85 LIST_AUDIO_PATCHES,
86 SET_AUDIO_PORT_CONFIG,
87 GET_AUDIO_HW_SYNC_FOR_SESSION,
88 SYSTEM_READY,
89 FRAME_COUNT_HAL,
90 GET_MICROPHONES,
91 SET_MASTER_BALANCE,
92 GET_MASTER_BALANCE,
93 SET_EFFECT_SUSPENDED,
94 SET_AUDIO_HAL_PIDS
95 };
96
97 #define MAX_ITEMS_PER_LIST 1024
98
99
100 class BpAudioFlinger : public BpInterface<IAudioFlinger>
101 {
102 public:
BpAudioFlinger(const sp<IBinder> & impl)103 explicit BpAudioFlinger(const sp<IBinder>& impl)
104 : BpInterface<IAudioFlinger>(impl)
105 {
106 }
107
createTrack(const CreateTrackInput & input,CreateTrackOutput & output,status_t * status)108 virtual sp<IAudioTrack> createTrack(const CreateTrackInput& input,
109 CreateTrackOutput& output,
110 status_t *status)
111 {
112 Parcel data, reply;
113 sp<IAudioTrack> track;
114 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
115
116 if (status == nullptr) {
117 return track;
118 }
119
120 input.writeToParcel(&data);
121
122 status_t lStatus = remote()->transact(CREATE_TRACK, data, &reply);
123 if (lStatus != NO_ERROR) {
124 ALOGE("createTrack transaction error %d", lStatus);
125 *status = DEAD_OBJECT;
126 return track;
127 }
128 *status = reply.readInt32();
129 if (*status != NO_ERROR) {
130 ALOGE("createTrack returned error %d", *status);
131 return track;
132 }
133 track = interface_cast<IAudioTrack>(reply.readStrongBinder());
134 if (track == 0) {
135 ALOGE("createTrack returned an NULL IAudioTrack with status OK");
136 *status = DEAD_OBJECT;
137 return track;
138 }
139 output.readFromParcel(&reply);
140 return track;
141 }
142
createRecord(const CreateRecordInput & input,CreateRecordOutput & output,status_t * status)143 virtual sp<media::IAudioRecord> createRecord(const CreateRecordInput& input,
144 CreateRecordOutput& output,
145 status_t *status)
146 {
147 Parcel data, reply;
148 sp<media::IAudioRecord> record;
149 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
150
151 if (status == nullptr) {
152 return record;
153 }
154
155 input.writeToParcel(&data);
156
157 status_t lStatus = remote()->transact(CREATE_RECORD, data, &reply);
158 if (lStatus != NO_ERROR) {
159 ALOGE("createRecord transaction error %d", lStatus);
160 *status = DEAD_OBJECT;
161 return record;
162 }
163 *status = reply.readInt32();
164 if (*status != NO_ERROR) {
165 ALOGE("createRecord returned error %d", *status);
166 return record;
167 }
168
169 record = interface_cast<media::IAudioRecord>(reply.readStrongBinder());
170 if (record == 0) {
171 ALOGE("createRecord returned a NULL IAudioRecord with status OK");
172 *status = DEAD_OBJECT;
173 return record;
174 }
175 output.readFromParcel(&reply);
176 return record;
177 }
178
sampleRate(audio_io_handle_t ioHandle) const179 virtual uint32_t sampleRate(audio_io_handle_t ioHandle) const
180 {
181 Parcel data, reply;
182 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
183 data.writeInt32((int32_t) ioHandle);
184 remote()->transact(SAMPLE_RATE, data, &reply);
185 return reply.readInt32();
186 }
187
188 // RESERVED for channelCount()
189
format(audio_io_handle_t output) const190 virtual audio_format_t format(audio_io_handle_t output) const
191 {
192 Parcel data, reply;
193 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
194 data.writeInt32((int32_t) output);
195 remote()->transact(FORMAT, data, &reply);
196 return (audio_format_t) reply.readInt32();
197 }
198
frameCount(audio_io_handle_t ioHandle) const199 virtual size_t frameCount(audio_io_handle_t ioHandle) const
200 {
201 Parcel data, reply;
202 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
203 data.writeInt32((int32_t) ioHandle);
204 remote()->transact(FRAME_COUNT, data, &reply);
205 return reply.readInt64();
206 }
207
latency(audio_io_handle_t output) const208 virtual uint32_t latency(audio_io_handle_t output) const
209 {
210 Parcel data, reply;
211 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
212 data.writeInt32((int32_t) output);
213 remote()->transact(LATENCY, data, &reply);
214 return reply.readInt32();
215 }
216
setMasterVolume(float value)217 virtual status_t setMasterVolume(float value)
218 {
219 Parcel data, reply;
220 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
221 data.writeFloat(value);
222 remote()->transact(SET_MASTER_VOLUME, data, &reply);
223 return reply.readInt32();
224 }
225
setMasterMute(bool muted)226 virtual status_t setMasterMute(bool muted)
227 {
228 Parcel data, reply;
229 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
230 data.writeInt32(muted);
231 remote()->transact(SET_MASTER_MUTE, data, &reply);
232 return reply.readInt32();
233 }
234
masterVolume() const235 virtual float masterVolume() const
236 {
237 Parcel data, reply;
238 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
239 remote()->transact(MASTER_VOLUME, data, &reply);
240 return reply.readFloat();
241 }
242
masterMute() const243 virtual bool masterMute() const
244 {
245 Parcel data, reply;
246 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
247 remote()->transact(MASTER_MUTE, data, &reply);
248 return reply.readInt32();
249 }
250
setMasterBalance(float balance)251 status_t setMasterBalance(float balance) override
252 {
253 Parcel data, reply;
254 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
255 data.writeFloat(balance);
256 status_t status = remote()->transact(SET_MASTER_BALANCE, data, &reply);
257 if (status != NO_ERROR) {
258 return status;
259 }
260 return reply.readInt32();
261 }
262
getMasterBalance(float * balance) const263 status_t getMasterBalance(float *balance) const override
264 {
265 Parcel data, reply;
266 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
267 status_t status = remote()->transact(GET_MASTER_BALANCE, data, &reply);
268 if (status != NO_ERROR) {
269 return status;
270 }
271 status = (status_t)reply.readInt32();
272 if (status != NO_ERROR) {
273 return status;
274 }
275 *balance = reply.readFloat();
276 return NO_ERROR;
277 }
278
setStreamVolume(audio_stream_type_t stream,float value,audio_io_handle_t output)279 virtual status_t setStreamVolume(audio_stream_type_t stream, float value,
280 audio_io_handle_t output)
281 {
282 Parcel data, reply;
283 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
284 data.writeInt32((int32_t) stream);
285 data.writeFloat(value);
286 data.writeInt32((int32_t) output);
287 remote()->transact(SET_STREAM_VOLUME, data, &reply);
288 return reply.readInt32();
289 }
290
setStreamMute(audio_stream_type_t stream,bool muted)291 virtual status_t setStreamMute(audio_stream_type_t stream, bool muted)
292 {
293 Parcel data, reply;
294 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
295 data.writeInt32((int32_t) stream);
296 data.writeInt32(muted);
297 remote()->transact(SET_STREAM_MUTE, data, &reply);
298 return reply.readInt32();
299 }
300
streamVolume(audio_stream_type_t stream,audio_io_handle_t output) const301 virtual float streamVolume(audio_stream_type_t stream, audio_io_handle_t output) const
302 {
303 Parcel data, reply;
304 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
305 data.writeInt32((int32_t) stream);
306 data.writeInt32((int32_t) output);
307 remote()->transact(STREAM_VOLUME, data, &reply);
308 return reply.readFloat();
309 }
310
streamMute(audio_stream_type_t stream) const311 virtual bool streamMute(audio_stream_type_t stream) const
312 {
313 Parcel data, reply;
314 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
315 data.writeInt32((int32_t) stream);
316 remote()->transact(STREAM_MUTE, data, &reply);
317 return reply.readInt32();
318 }
319
setMode(audio_mode_t mode)320 virtual status_t setMode(audio_mode_t mode)
321 {
322 Parcel data, reply;
323 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
324 data.writeInt32(mode);
325 remote()->transact(SET_MODE, data, &reply);
326 return reply.readInt32();
327 }
328
setMicMute(bool state)329 virtual status_t setMicMute(bool state)
330 {
331 Parcel data, reply;
332 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
333 data.writeInt32(state);
334 remote()->transact(SET_MIC_MUTE, data, &reply);
335 return reply.readInt32();
336 }
337
getMicMute() const338 virtual bool getMicMute() const
339 {
340 Parcel data, reply;
341 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
342 remote()->transact(GET_MIC_MUTE, data, &reply);
343 return reply.readInt32();
344 }
345
setRecordSilenced(audio_port_handle_t portId,bool silenced)346 virtual void setRecordSilenced(audio_port_handle_t portId, bool silenced)
347 {
348 Parcel data, reply;
349 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
350 data.writeInt32(portId);
351 data.writeInt32(silenced ? 1 : 0);
352 remote()->transact(SET_RECORD_SILENCED, data, &reply);
353 }
354
setParameters(audio_io_handle_t ioHandle,const String8 & keyValuePairs)355 virtual status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs)
356 {
357 Parcel data, reply;
358 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
359 data.writeInt32((int32_t) ioHandle);
360 data.writeString8(keyValuePairs);
361 remote()->transact(SET_PARAMETERS, data, &reply);
362 return reply.readInt32();
363 }
364
getParameters(audio_io_handle_t ioHandle,const String8 & keys) const365 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) const
366 {
367 Parcel data, reply;
368 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
369 data.writeInt32((int32_t) ioHandle);
370 data.writeString8(keys);
371 remote()->transact(GET_PARAMETERS, data, &reply);
372 return reply.readString8();
373 }
374
registerClient(const sp<IAudioFlingerClient> & client)375 virtual void registerClient(const sp<IAudioFlingerClient>& client)
376 {
377 Parcel data, reply;
378 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
379 data.writeStrongBinder(IInterface::asBinder(client));
380 remote()->transact(REGISTER_CLIENT, data, &reply);
381 }
382
getInputBufferSize(uint32_t sampleRate,audio_format_t format,audio_channel_mask_t channelMask) const383 virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format,
384 audio_channel_mask_t channelMask) const
385 {
386 Parcel data, reply;
387 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
388 data.writeInt32(sampleRate);
389 data.writeInt32(format);
390 data.writeInt32(channelMask);
391 remote()->transact(GET_INPUTBUFFERSIZE, data, &reply);
392 return reply.readInt64();
393 }
394
openOutput(audio_module_handle_t module,audio_io_handle_t * output,audio_config_t * config,const sp<DeviceDescriptorBase> & device,uint32_t * latencyMs,audio_output_flags_t flags)395 virtual status_t openOutput(audio_module_handle_t module,
396 audio_io_handle_t *output,
397 audio_config_t *config,
398 const sp<DeviceDescriptorBase>& device,
399 uint32_t *latencyMs,
400 audio_output_flags_t flags)
401 {
402 if (output == nullptr || config == nullptr || device == nullptr || latencyMs == nullptr) {
403 return BAD_VALUE;
404 }
405 Parcel data, reply;
406 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
407 data.writeInt32(module);
408 data.write(config, sizeof(audio_config_t));
409 data.writeParcelable(*device);
410 data.writeInt32((int32_t) flags);
411 status_t status = remote()->transact(OPEN_OUTPUT, data, &reply);
412 if (status != NO_ERROR) {
413 *output = AUDIO_IO_HANDLE_NONE;
414 return status;
415 }
416 status = (status_t)reply.readInt32();
417 if (status != NO_ERROR) {
418 *output = AUDIO_IO_HANDLE_NONE;
419 return status;
420 }
421 *output = (audio_io_handle_t)reply.readInt32();
422 ALOGV("openOutput() returned output, %d", *output);
423 reply.read(config, sizeof(audio_config_t));
424 *latencyMs = reply.readInt32();
425 return NO_ERROR;
426 }
427
openDuplicateOutput(audio_io_handle_t output1,audio_io_handle_t output2)428 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1,
429 audio_io_handle_t output2)
430 {
431 Parcel data, reply;
432 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
433 data.writeInt32((int32_t) output1);
434 data.writeInt32((int32_t) output2);
435 remote()->transact(OPEN_DUPLICATE_OUTPUT, data, &reply);
436 return (audio_io_handle_t) reply.readInt32();
437 }
438
closeOutput(audio_io_handle_t output)439 virtual status_t closeOutput(audio_io_handle_t output)
440 {
441 Parcel data, reply;
442 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
443 data.writeInt32((int32_t) output);
444 remote()->transact(CLOSE_OUTPUT, data, &reply);
445 return reply.readInt32();
446 }
447
suspendOutput(audio_io_handle_t output)448 virtual status_t suspendOutput(audio_io_handle_t output)
449 {
450 Parcel data, reply;
451 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
452 data.writeInt32((int32_t) output);
453 remote()->transact(SUSPEND_OUTPUT, data, &reply);
454 return reply.readInt32();
455 }
456
restoreOutput(audio_io_handle_t output)457 virtual status_t restoreOutput(audio_io_handle_t output)
458 {
459 Parcel data, reply;
460 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
461 data.writeInt32((int32_t) output);
462 remote()->transact(RESTORE_OUTPUT, data, &reply);
463 return reply.readInt32();
464 }
465
openInput(audio_module_handle_t module,audio_io_handle_t * input,audio_config_t * config,audio_devices_t * device,const String8 & address,audio_source_t source,audio_input_flags_t flags)466 virtual status_t openInput(audio_module_handle_t module,
467 audio_io_handle_t *input,
468 audio_config_t *config,
469 audio_devices_t *device,
470 const String8& address,
471 audio_source_t source,
472 audio_input_flags_t flags)
473 {
474 if (input == NULL || config == NULL || device == NULL) {
475 return BAD_VALUE;
476 }
477 Parcel data, reply;
478 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
479 data.writeInt32(module);
480 data.writeInt32(*input);
481 data.write(config, sizeof(audio_config_t));
482 data.writeInt32(*device);
483 data.writeString8(address);
484 data.writeInt32(source);
485 data.writeInt32(flags);
486 status_t status = remote()->transact(OPEN_INPUT, data, &reply);
487 if (status != NO_ERROR) {
488 *input = AUDIO_IO_HANDLE_NONE;
489 return status;
490 }
491 status = (status_t)reply.readInt32();
492 if (status != NO_ERROR) {
493 *input = AUDIO_IO_HANDLE_NONE;
494 return status;
495 }
496 *input = (audio_io_handle_t)reply.readInt32();
497 reply.read(config, sizeof(audio_config_t));
498 *device = (audio_devices_t)reply.readInt32();
499 return NO_ERROR;
500 }
501
closeInput(int input)502 virtual status_t closeInput(int input)
503 {
504 Parcel data, reply;
505 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
506 data.writeInt32(input);
507 remote()->transact(CLOSE_INPUT, data, &reply);
508 return reply.readInt32();
509 }
510
invalidateStream(audio_stream_type_t stream)511 virtual status_t invalidateStream(audio_stream_type_t stream)
512 {
513 Parcel data, reply;
514 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
515 data.writeInt32((int32_t) stream);
516 remote()->transact(INVALIDATE_STREAM, data, &reply);
517 return reply.readInt32();
518 }
519
setVoiceVolume(float volume)520 virtual status_t setVoiceVolume(float volume)
521 {
522 Parcel data, reply;
523 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
524 data.writeFloat(volume);
525 remote()->transact(SET_VOICE_VOLUME, data, &reply);
526 return reply.readInt32();
527 }
528
getRenderPosition(uint32_t * halFrames,uint32_t * dspFrames,audio_io_handle_t output) const529 virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames,
530 audio_io_handle_t output) const
531 {
532 Parcel data, reply;
533 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
534 data.writeInt32((int32_t) output);
535 remote()->transact(GET_RENDER_POSITION, data, &reply);
536 status_t status = reply.readInt32();
537 if (status == NO_ERROR) {
538 uint32_t tmp = reply.readInt32();
539 if (halFrames != NULL) {
540 *halFrames = tmp;
541 }
542 tmp = reply.readInt32();
543 if (dspFrames != NULL) {
544 *dspFrames = tmp;
545 }
546 }
547 return status;
548 }
549
getInputFramesLost(audio_io_handle_t ioHandle) const550 virtual uint32_t getInputFramesLost(audio_io_handle_t ioHandle) const
551 {
552 Parcel data, reply;
553 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
554 data.writeInt32((int32_t) ioHandle);
555 status_t status = remote()->transact(GET_INPUT_FRAMES_LOST, data, &reply);
556 if (status != NO_ERROR) {
557 return 0;
558 }
559 return (uint32_t) reply.readInt32();
560 }
561
newAudioUniqueId(audio_unique_id_use_t use)562 virtual audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use)
563 {
564 Parcel data, reply;
565 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
566 data.writeInt32((int32_t) use);
567 status_t status = remote()->transact(NEW_AUDIO_UNIQUE_ID, data, &reply);
568 audio_unique_id_t id = AUDIO_UNIQUE_ID_ALLOCATE;
569 if (status == NO_ERROR) {
570 id = reply.readInt32();
571 }
572 return id;
573 }
574
acquireAudioSessionId(audio_session_t audioSession,pid_t pid,uid_t uid)575 void acquireAudioSessionId(audio_session_t audioSession, pid_t pid, uid_t uid) override
576 {
577 Parcel data, reply;
578 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
579 data.writeInt32(audioSession);
580 data.writeInt32((int32_t)pid);
581 data.writeInt32((int32_t)uid);
582 remote()->transact(ACQUIRE_AUDIO_SESSION_ID, data, &reply);
583 }
584
releaseAudioSessionId(audio_session_t audioSession,int pid)585 virtual void releaseAudioSessionId(audio_session_t audioSession, int pid)
586 {
587 Parcel data, reply;
588 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
589 data.writeInt32(audioSession);
590 data.writeInt32(pid);
591 remote()->transact(RELEASE_AUDIO_SESSION_ID, data, &reply);
592 }
593
queryNumberEffects(uint32_t * numEffects) const594 virtual status_t queryNumberEffects(uint32_t *numEffects) const
595 {
596 Parcel data, reply;
597 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
598 status_t status = remote()->transact(QUERY_NUM_EFFECTS, data, &reply);
599 if (status != NO_ERROR) {
600 return status;
601 }
602 status = reply.readInt32();
603 if (status != NO_ERROR) {
604 return status;
605 }
606 if (numEffects != NULL) {
607 *numEffects = (uint32_t)reply.readInt32();
608 }
609 return NO_ERROR;
610 }
611
queryEffect(uint32_t index,effect_descriptor_t * pDescriptor) const612 virtual status_t queryEffect(uint32_t index, effect_descriptor_t *pDescriptor) const
613 {
614 if (pDescriptor == NULL) {
615 return BAD_VALUE;
616 }
617 Parcel data, reply;
618 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
619 data.writeInt32(index);
620 status_t status = remote()->transact(QUERY_EFFECT, data, &reply);
621 if (status != NO_ERROR) {
622 return status;
623 }
624 status = reply.readInt32();
625 if (status != NO_ERROR) {
626 return status;
627 }
628 reply.read(pDescriptor, sizeof(effect_descriptor_t));
629 return NO_ERROR;
630 }
631
getEffectDescriptor(const effect_uuid_t * pUuid,const effect_uuid_t * pType,uint32_t preferredTypeFlag,effect_descriptor_t * pDescriptor) const632 virtual status_t getEffectDescriptor(const effect_uuid_t *pUuid,
633 const effect_uuid_t *pType,
634 uint32_t preferredTypeFlag,
635 effect_descriptor_t *pDescriptor) const
636 {
637 if (pUuid == NULL || pType == NULL || pDescriptor == NULL) {
638 return BAD_VALUE;
639 }
640 Parcel data, reply;
641 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
642 data.write(pUuid, sizeof(effect_uuid_t));
643 data.write(pType, sizeof(effect_uuid_t));
644 data.writeUint32(preferredTypeFlag);
645 status_t status = remote()->transact(GET_EFFECT_DESCRIPTOR, data, &reply);
646 if (status != NO_ERROR) {
647 return status;
648 }
649 status = reply.readInt32();
650 if (status != NO_ERROR) {
651 return status;
652 }
653 reply.read(pDescriptor, sizeof(effect_descriptor_t));
654 return NO_ERROR;
655 }
656
createEffect(effect_descriptor_t * pDesc,const sp<IEffectClient> & client,int32_t priority,audio_io_handle_t output,audio_session_t sessionId,const AudioDeviceTypeAddr & device,const String16 & opPackageName,pid_t pid,bool probe,status_t * status,int * id,int * enabled)657 virtual sp<IEffect> createEffect(
658 effect_descriptor_t *pDesc,
659 const sp<IEffectClient>& client,
660 int32_t priority,
661 audio_io_handle_t output,
662 audio_session_t sessionId,
663 const AudioDeviceTypeAddr& device,
664 const String16& opPackageName,
665 pid_t pid,
666 bool probe,
667 status_t *status,
668 int *id,
669 int *enabled)
670 {
671 Parcel data, reply;
672 sp<IEffect> effect;
673 if (pDesc == NULL) {
674 if (status != NULL) {
675 *status = BAD_VALUE;
676 }
677 return nullptr;
678 }
679
680 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
681 data.write(pDesc, sizeof(effect_descriptor_t));
682 data.writeStrongBinder(IInterface::asBinder(client));
683 data.writeInt32(priority);
684 data.writeInt32((int32_t) output);
685 data.writeInt32(sessionId);
686 if (data.writeParcelable(device) != NO_ERROR) {
687 if (status != NULL) {
688 *status = NO_INIT;
689 }
690 return nullptr;
691 }
692 data.writeString16(opPackageName);
693 data.writeInt32((int32_t) pid);
694 data.writeInt32(probe ? 1 : 0);
695
696 status_t lStatus = remote()->transact(CREATE_EFFECT, data, &reply);
697 if (lStatus != NO_ERROR) {
698 ALOGE("createEffect error: %s", strerror(-lStatus));
699 } else {
700 lStatus = reply.readInt32();
701 int tmp = reply.readInt32();
702 if (id != NULL) {
703 *id = tmp;
704 }
705 tmp = reply.readInt32();
706 if (enabled != NULL) {
707 *enabled = tmp;
708 }
709 effect = interface_cast<IEffect>(reply.readStrongBinder());
710 reply.read(pDesc, sizeof(effect_descriptor_t));
711 }
712 if (status != NULL) {
713 *status = lStatus;
714 }
715
716 return effect;
717 }
718
moveEffects(audio_session_t session,audio_io_handle_t srcOutput,audio_io_handle_t dstOutput)719 virtual status_t moveEffects(audio_session_t session, audio_io_handle_t srcOutput,
720 audio_io_handle_t dstOutput)
721 {
722 Parcel data, reply;
723 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
724 data.writeInt32(session);
725 data.writeInt32((int32_t) srcOutput);
726 data.writeInt32((int32_t) dstOutput);
727 remote()->transact(MOVE_EFFECTS, data, &reply);
728 return reply.readInt32();
729 }
730
setEffectSuspended(int effectId,audio_session_t sessionId,bool suspended)731 virtual void setEffectSuspended(int effectId,
732 audio_session_t sessionId,
733 bool suspended)
734 {
735 Parcel data, reply;
736 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
737 data.writeInt32(effectId);
738 data.writeInt32(sessionId);
739 data.writeInt32(suspended ? 1 : 0);
740 remote()->transact(SET_EFFECT_SUSPENDED, data, &reply);
741 }
742
loadHwModule(const char * name)743 virtual audio_module_handle_t loadHwModule(const char *name)
744 {
745 Parcel data, reply;
746 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
747 data.writeCString(name);
748 remote()->transact(LOAD_HW_MODULE, data, &reply);
749 return (audio_module_handle_t) reply.readInt32();
750 }
751
getPrimaryOutputSamplingRate()752 virtual uint32_t getPrimaryOutputSamplingRate()
753 {
754 Parcel data, reply;
755 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
756 remote()->transact(GET_PRIMARY_OUTPUT_SAMPLING_RATE, data, &reply);
757 return reply.readInt32();
758 }
759
getPrimaryOutputFrameCount()760 virtual size_t getPrimaryOutputFrameCount()
761 {
762 Parcel data, reply;
763 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
764 remote()->transact(GET_PRIMARY_OUTPUT_FRAME_COUNT, data, &reply);
765 return reply.readInt64();
766 }
767
setLowRamDevice(bool isLowRamDevice,int64_t totalMemory)768 virtual status_t setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) override
769 {
770 Parcel data, reply;
771
772 static_assert(NO_ERROR == 0, "NO_ERROR must be 0");
773 return data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor())
774 ?: data.writeInt32((int) isLowRamDevice)
775 ?: data.writeInt64(totalMemory)
776 ?: remote()->transact(SET_LOW_RAM_DEVICE, data, &reply)
777 ?: reply.readInt32();
778 }
779
listAudioPorts(unsigned int * num_ports,struct audio_port * ports)780 virtual status_t listAudioPorts(unsigned int *num_ports,
781 struct audio_port *ports)
782 {
783 if (num_ports == NULL || *num_ports == 0 || ports == NULL) {
784 return BAD_VALUE;
785 }
786 Parcel data, reply;
787 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
788 data.writeInt32(*num_ports);
789 status_t status = remote()->transact(LIST_AUDIO_PORTS, data, &reply);
790 if (status != NO_ERROR ||
791 (status = (status_t)reply.readInt32()) != NO_ERROR) {
792 return status;
793 }
794 *num_ports = (unsigned int)reply.readInt32();
795 reply.read(ports, *num_ports * sizeof(struct audio_port));
796 return status;
797 }
getAudioPort(struct audio_port * port)798 virtual status_t getAudioPort(struct audio_port *port)
799 {
800 if (port == NULL) {
801 return BAD_VALUE;
802 }
803 Parcel data, reply;
804 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
805 data.write(port, sizeof(struct audio_port));
806 status_t status = remote()->transact(GET_AUDIO_PORT, data, &reply);
807 if (status != NO_ERROR ||
808 (status = (status_t)reply.readInt32()) != NO_ERROR) {
809 return status;
810 }
811 reply.read(port, sizeof(struct audio_port));
812 return status;
813 }
createAudioPatch(const struct audio_patch * patch,audio_patch_handle_t * handle)814 virtual status_t createAudioPatch(const struct audio_patch *patch,
815 audio_patch_handle_t *handle)
816 {
817 if (patch == NULL || handle == NULL) {
818 return BAD_VALUE;
819 }
820 Parcel data, reply;
821 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
822 data.write(patch, sizeof(struct audio_patch));
823 data.write(handle, sizeof(audio_patch_handle_t));
824 status_t status = remote()->transact(CREATE_AUDIO_PATCH, data, &reply);
825 if (status != NO_ERROR ||
826 (status = (status_t)reply.readInt32()) != NO_ERROR) {
827 return status;
828 }
829 reply.read(handle, sizeof(audio_patch_handle_t));
830 return status;
831 }
releaseAudioPatch(audio_patch_handle_t handle)832 virtual status_t releaseAudioPatch(audio_patch_handle_t handle)
833 {
834 Parcel data, reply;
835 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
836 data.write(&handle, sizeof(audio_patch_handle_t));
837 status_t status = remote()->transact(RELEASE_AUDIO_PATCH, data, &reply);
838 if (status != NO_ERROR) {
839 status = (status_t)reply.readInt32();
840 }
841 return status;
842 }
listAudioPatches(unsigned int * num_patches,struct audio_patch * patches)843 virtual status_t listAudioPatches(unsigned int *num_patches,
844 struct audio_patch *patches)
845 {
846 if (num_patches == NULL || *num_patches == 0 || patches == NULL) {
847 return BAD_VALUE;
848 }
849 Parcel data, reply;
850 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
851 data.writeInt32(*num_patches);
852 status_t status = remote()->transact(LIST_AUDIO_PATCHES, data, &reply);
853 if (status != NO_ERROR ||
854 (status = (status_t)reply.readInt32()) != NO_ERROR) {
855 return status;
856 }
857 *num_patches = (unsigned int)reply.readInt32();
858 reply.read(patches, *num_patches * sizeof(struct audio_patch));
859 return status;
860 }
setAudioPortConfig(const struct audio_port_config * config)861 virtual status_t setAudioPortConfig(const struct audio_port_config *config)
862 {
863 if (config == NULL) {
864 return BAD_VALUE;
865 }
866 Parcel data, reply;
867 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
868 data.write(config, sizeof(struct audio_port_config));
869 status_t status = remote()->transact(SET_AUDIO_PORT_CONFIG, data, &reply);
870 if (status != NO_ERROR) {
871 status = (status_t)reply.readInt32();
872 }
873 return status;
874 }
getAudioHwSyncForSession(audio_session_t sessionId)875 virtual audio_hw_sync_t getAudioHwSyncForSession(audio_session_t sessionId)
876 {
877 Parcel data, reply;
878 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
879 data.writeInt32(sessionId);
880 status_t status = remote()->transact(GET_AUDIO_HW_SYNC_FOR_SESSION, data, &reply);
881 if (status != NO_ERROR) {
882 return AUDIO_HW_SYNC_INVALID;
883 }
884 return (audio_hw_sync_t)reply.readInt32();
885 }
systemReady()886 virtual status_t systemReady()
887 {
888 Parcel data, reply;
889 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
890 return remote()->transact(SYSTEM_READY, data, &reply, IBinder::FLAG_ONEWAY);
891 }
frameCountHAL(audio_io_handle_t ioHandle) const892 virtual size_t frameCountHAL(audio_io_handle_t ioHandle) const
893 {
894 Parcel data, reply;
895 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
896 data.writeInt32((int32_t) ioHandle);
897 status_t status = remote()->transact(FRAME_COUNT_HAL, data, &reply);
898 if (status != NO_ERROR) {
899 return 0;
900 }
901 return reply.readInt64();
902 }
getMicrophones(std::vector<media::MicrophoneInfo> * microphones)903 virtual status_t getMicrophones(std::vector<media::MicrophoneInfo> *microphones)
904 {
905 Parcel data, reply;
906 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
907 status_t status = remote()->transact(GET_MICROPHONES, data, &reply);
908 if (status != NO_ERROR ||
909 (status = (status_t)reply.readInt32()) != NO_ERROR) {
910 return status;
911 }
912 status = reply.readParcelableVector(microphones);
913 return status;
914 }
setAudioHalPids(const std::vector<pid_t> & pids)915 virtual status_t setAudioHalPids(const std::vector<pid_t>& pids)
916 {
917 Parcel data, reply;
918 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
919 data.writeInt32(pids.size());
920 for (auto pid : pids) {
921 data.writeInt32(pid);
922 }
923 status_t status = remote()->transact(SET_AUDIO_HAL_PIDS, data, &reply);
924 if (status != NO_ERROR) {
925 return status;
926 }
927 return static_cast <status_t> (reply.readInt32());
928 }
929 };
930
931 IMPLEMENT_META_INTERFACE(AudioFlinger, "android.media.IAudioFlinger");
932
933 // ----------------------------------------------------------------------
934
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)935 status_t BnAudioFlinger::onTransact(
936 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
937 {
938 // make sure transactions reserved to AudioPolicyManager do not come from other processes
939 switch (code) {
940 case SET_STREAM_VOLUME:
941 case SET_STREAM_MUTE:
942 case OPEN_OUTPUT:
943 case OPEN_DUPLICATE_OUTPUT:
944 case CLOSE_OUTPUT:
945 case SUSPEND_OUTPUT:
946 case RESTORE_OUTPUT:
947 case OPEN_INPUT:
948 case CLOSE_INPUT:
949 case INVALIDATE_STREAM:
950 case SET_VOICE_VOLUME:
951 case MOVE_EFFECTS:
952 case SET_EFFECT_SUSPENDED:
953 case LOAD_HW_MODULE:
954 case LIST_AUDIO_PORTS:
955 case GET_AUDIO_PORT:
956 case CREATE_AUDIO_PATCH:
957 case RELEASE_AUDIO_PATCH:
958 case LIST_AUDIO_PATCHES:
959 case SET_AUDIO_PORT_CONFIG:
960 case SET_RECORD_SILENCED:
961 ALOGW("%s: transaction %d received from PID %d",
962 __func__, code, IPCThreadState::self()->getCallingPid());
963 // return status only for non void methods
964 switch (code) {
965 case SET_RECORD_SILENCED:
966 case SET_EFFECT_SUSPENDED:
967 break;
968 default:
969 reply->writeInt32(static_cast<int32_t> (INVALID_OPERATION));
970 break;
971 }
972 return OK;
973 default:
974 break;
975 }
976
977 // make sure the following transactions come from system components
978 switch (code) {
979 case SET_MASTER_VOLUME:
980 case SET_MASTER_MUTE:
981 case SET_MODE:
982 case SET_MIC_MUTE:
983 case SET_LOW_RAM_DEVICE:
984 case SYSTEM_READY:
985 case SET_AUDIO_HAL_PIDS: {
986 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
987 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
988 __func__, code, IPCThreadState::self()->getCallingPid(),
989 IPCThreadState::self()->getCallingUid());
990 // return status only for non void methods
991 switch (code) {
992 case SYSTEM_READY:
993 break;
994 default:
995 reply->writeInt32(static_cast<int32_t> (INVALID_OPERATION));
996 break;
997 }
998 return OK;
999 }
1000 } break;
1001 default:
1002 break;
1003 }
1004
1005 // Whitelist of relevant events to trigger log merging.
1006 // Log merging should activate during audio activity of any kind. This are considered the
1007 // most relevant events.
1008 // TODO should select more wisely the items from the list
1009 switch (code) {
1010 case CREATE_TRACK:
1011 case CREATE_RECORD:
1012 case SET_MASTER_VOLUME:
1013 case SET_MASTER_MUTE:
1014 case SET_MIC_MUTE:
1015 case SET_PARAMETERS:
1016 case CREATE_EFFECT:
1017 case SYSTEM_READY: {
1018 requestLogMerge();
1019 break;
1020 }
1021 default:
1022 break;
1023 }
1024
1025 std::string tag("IAudioFlinger command " + std::to_string(code));
1026 TimeCheck check(tag.c_str());
1027
1028 switch (code) {
1029 case CREATE_TRACK: {
1030 CHECK_INTERFACE(IAudioFlinger, data, reply);
1031
1032 CreateTrackInput input;
1033 if (input.readFromParcel((Parcel*)&data) != NO_ERROR) {
1034 reply->writeInt32(DEAD_OBJECT);
1035 return NO_ERROR;
1036 }
1037
1038 status_t status;
1039 CreateTrackOutput output;
1040
1041 sp<IAudioTrack> track= createTrack(input,
1042 output,
1043 &status);
1044
1045 LOG_ALWAYS_FATAL_IF((track != 0) != (status == NO_ERROR));
1046 reply->writeInt32(status);
1047 if (status != NO_ERROR) {
1048 return NO_ERROR;
1049 }
1050 reply->writeStrongBinder(IInterface::asBinder(track));
1051 output.writeToParcel(reply);
1052 return NO_ERROR;
1053 } break;
1054 case CREATE_RECORD: {
1055 CHECK_INTERFACE(IAudioFlinger, data, reply);
1056
1057 CreateRecordInput input;
1058 if (input.readFromParcel((Parcel*)&data) != NO_ERROR) {
1059 reply->writeInt32(DEAD_OBJECT);
1060 return NO_ERROR;
1061 }
1062
1063 status_t status;
1064 CreateRecordOutput output;
1065
1066 sp<media::IAudioRecord> record = createRecord(input,
1067 output,
1068 &status);
1069
1070 LOG_ALWAYS_FATAL_IF((record != 0) != (status == NO_ERROR));
1071 reply->writeInt32(status);
1072 if (status != NO_ERROR) {
1073 return NO_ERROR;
1074 }
1075 reply->writeStrongBinder(IInterface::asBinder(record));
1076 output.writeToParcel(reply);
1077 return NO_ERROR;
1078 } break;
1079 case SAMPLE_RATE: {
1080 CHECK_INTERFACE(IAudioFlinger, data, reply);
1081 reply->writeInt32( sampleRate((audio_io_handle_t) data.readInt32()) );
1082 return NO_ERROR;
1083 } break;
1084
1085 // RESERVED for channelCount()
1086
1087 case FORMAT: {
1088 CHECK_INTERFACE(IAudioFlinger, data, reply);
1089 reply->writeInt32( format((audio_io_handle_t) data.readInt32()) );
1090 return NO_ERROR;
1091 } break;
1092 case FRAME_COUNT: {
1093 CHECK_INTERFACE(IAudioFlinger, data, reply);
1094 reply->writeInt64( frameCount((audio_io_handle_t) data.readInt32()) );
1095 return NO_ERROR;
1096 } break;
1097 case LATENCY: {
1098 CHECK_INTERFACE(IAudioFlinger, data, reply);
1099 reply->writeInt32( latency((audio_io_handle_t) data.readInt32()) );
1100 return NO_ERROR;
1101 } break;
1102 case SET_MASTER_VOLUME: {
1103 CHECK_INTERFACE(IAudioFlinger, data, reply);
1104 reply->writeInt32( setMasterVolume(data.readFloat()) );
1105 return NO_ERROR;
1106 } break;
1107 case SET_MASTER_MUTE: {
1108 CHECK_INTERFACE(IAudioFlinger, data, reply);
1109 reply->writeInt32( setMasterMute(data.readInt32()) );
1110 return NO_ERROR;
1111 } break;
1112 case MASTER_VOLUME: {
1113 CHECK_INTERFACE(IAudioFlinger, data, reply);
1114 reply->writeFloat( masterVolume() );
1115 return NO_ERROR;
1116 } break;
1117 case MASTER_MUTE: {
1118 CHECK_INTERFACE(IAudioFlinger, data, reply);
1119 reply->writeInt32( masterMute() );
1120 return NO_ERROR;
1121 } break;
1122 case SET_MASTER_BALANCE: {
1123 CHECK_INTERFACE(IAudioFlinger, data, reply);
1124 reply->writeInt32( setMasterBalance(data.readFloat()) );
1125 return NO_ERROR;
1126 } break;
1127 case GET_MASTER_BALANCE: {
1128 CHECK_INTERFACE(IAudioFlinger, data, reply);
1129 float f;
1130 const status_t status = getMasterBalance(&f);
1131 reply->writeInt32((int32_t)status);
1132 if (status == NO_ERROR) {
1133 (void)reply->writeFloat(f);
1134 }
1135 return NO_ERROR;
1136 } break;
1137 case SET_STREAM_VOLUME: {
1138 CHECK_INTERFACE(IAudioFlinger, data, reply);
1139 int stream = data.readInt32();
1140 float volume = data.readFloat();
1141 audio_io_handle_t output = (audio_io_handle_t) data.readInt32();
1142 reply->writeInt32( setStreamVolume((audio_stream_type_t) stream, volume, output) );
1143 return NO_ERROR;
1144 } break;
1145 case SET_STREAM_MUTE: {
1146 CHECK_INTERFACE(IAudioFlinger, data, reply);
1147 int stream = data.readInt32();
1148 reply->writeInt32( setStreamMute((audio_stream_type_t) stream, data.readInt32()) );
1149 return NO_ERROR;
1150 } break;
1151 case STREAM_VOLUME: {
1152 CHECK_INTERFACE(IAudioFlinger, data, reply);
1153 int stream = data.readInt32();
1154 int output = data.readInt32();
1155 reply->writeFloat( streamVolume((audio_stream_type_t) stream, output) );
1156 return NO_ERROR;
1157 } break;
1158 case STREAM_MUTE: {
1159 CHECK_INTERFACE(IAudioFlinger, data, reply);
1160 int stream = data.readInt32();
1161 reply->writeInt32( streamMute((audio_stream_type_t) stream) );
1162 return NO_ERROR;
1163 } break;
1164 case SET_MODE: {
1165 CHECK_INTERFACE(IAudioFlinger, data, reply);
1166 audio_mode_t mode = (audio_mode_t) data.readInt32();
1167 reply->writeInt32( setMode(mode) );
1168 return NO_ERROR;
1169 } break;
1170 case SET_MIC_MUTE: {
1171 CHECK_INTERFACE(IAudioFlinger, data, reply);
1172 int state = data.readInt32();
1173 reply->writeInt32( setMicMute(state) );
1174 return NO_ERROR;
1175 } break;
1176 case GET_MIC_MUTE: {
1177 CHECK_INTERFACE(IAudioFlinger, data, reply);
1178 reply->writeInt32( getMicMute() );
1179 return NO_ERROR;
1180 } break;
1181 case SET_RECORD_SILENCED: {
1182 CHECK_INTERFACE(IAudioFlinger, data, reply);
1183 audio_port_handle_t portId = data.readInt32();
1184 bool silenced = data.readInt32() == 1;
1185 setRecordSilenced(portId, silenced);
1186 return NO_ERROR;
1187 } break;
1188 case SET_PARAMETERS: {
1189 CHECK_INTERFACE(IAudioFlinger, data, reply);
1190 audio_io_handle_t ioHandle = (audio_io_handle_t) data.readInt32();
1191 String8 keyValuePairs(data.readString8());
1192 reply->writeInt32(setParameters(ioHandle, keyValuePairs));
1193 return NO_ERROR;
1194 } break;
1195 case GET_PARAMETERS: {
1196 CHECK_INTERFACE(IAudioFlinger, data, reply);
1197 audio_io_handle_t ioHandle = (audio_io_handle_t) data.readInt32();
1198 String8 keys(data.readString8());
1199 reply->writeString8(getParameters(ioHandle, keys));
1200 return NO_ERROR;
1201 } break;
1202
1203 case REGISTER_CLIENT: {
1204 CHECK_INTERFACE(IAudioFlinger, data, reply);
1205 sp<IAudioFlingerClient> client = interface_cast<IAudioFlingerClient>(
1206 data.readStrongBinder());
1207 registerClient(client);
1208 return NO_ERROR;
1209 } break;
1210 case GET_INPUTBUFFERSIZE: {
1211 CHECK_INTERFACE(IAudioFlinger, data, reply);
1212 uint32_t sampleRate = data.readInt32();
1213 audio_format_t format = (audio_format_t) data.readInt32();
1214 audio_channel_mask_t channelMask = data.readInt32();
1215 reply->writeInt64( getInputBufferSize(sampleRate, format, channelMask) );
1216 return NO_ERROR;
1217 } break;
1218 case OPEN_OUTPUT: {
1219 CHECK_INTERFACE(IAudioFlinger, data, reply);
1220 audio_module_handle_t module = (audio_module_handle_t)data.readInt32();
1221 audio_config_t config = {};
1222 if (data.read(&config, sizeof(audio_config_t)) != NO_ERROR) {
1223 ALOGE("b/23905951");
1224 }
1225 sp<DeviceDescriptorBase> device = new DeviceDescriptorBase(AUDIO_DEVICE_NONE);
1226 status_t status = NO_ERROR;
1227 if ((status = data.readParcelable(device.get())) != NO_ERROR) {
1228 reply->writeInt32((int32_t)status);
1229 return NO_ERROR;
1230 }
1231 audio_output_flags_t flags = (audio_output_flags_t) data.readInt32();
1232 uint32_t latencyMs = 0;
1233 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
1234 status = openOutput(module, &output, &config, device, &latencyMs, flags);
1235 ALOGV("OPEN_OUTPUT output, %d", output);
1236 reply->writeInt32((int32_t)status);
1237 if (status == NO_ERROR) {
1238 reply->writeInt32((int32_t)output);
1239 reply->write(&config, sizeof(audio_config_t));
1240 reply->writeInt32(latencyMs);
1241 }
1242 return NO_ERROR;
1243 } break;
1244 case OPEN_DUPLICATE_OUTPUT: {
1245 CHECK_INTERFACE(IAudioFlinger, data, reply);
1246 audio_io_handle_t output1 = (audio_io_handle_t) data.readInt32();
1247 audio_io_handle_t output2 = (audio_io_handle_t) data.readInt32();
1248 reply->writeInt32((int32_t) openDuplicateOutput(output1, output2));
1249 return NO_ERROR;
1250 } break;
1251 case CLOSE_OUTPUT: {
1252 CHECK_INTERFACE(IAudioFlinger, data, reply);
1253 reply->writeInt32(closeOutput((audio_io_handle_t) data.readInt32()));
1254 return NO_ERROR;
1255 } break;
1256 case SUSPEND_OUTPUT: {
1257 CHECK_INTERFACE(IAudioFlinger, data, reply);
1258 reply->writeInt32(suspendOutput((audio_io_handle_t) data.readInt32()));
1259 return NO_ERROR;
1260 } break;
1261 case RESTORE_OUTPUT: {
1262 CHECK_INTERFACE(IAudioFlinger, data, reply);
1263 reply->writeInt32(restoreOutput((audio_io_handle_t) data.readInt32()));
1264 return NO_ERROR;
1265 } break;
1266 case OPEN_INPUT: {
1267 CHECK_INTERFACE(IAudioFlinger, data, reply);
1268 audio_module_handle_t module = (audio_module_handle_t)data.readInt32();
1269 audio_io_handle_t input = (audio_io_handle_t)data.readInt32();
1270 audio_config_t config = {};
1271 if (data.read(&config, sizeof(audio_config_t)) != NO_ERROR) {
1272 ALOGE("b/23905951");
1273 }
1274 audio_devices_t device = (audio_devices_t)data.readInt32();
1275 String8 address(data.readString8());
1276 audio_source_t source = (audio_source_t)data.readInt32();
1277 audio_input_flags_t flags = (audio_input_flags_t) data.readInt32();
1278
1279 status_t status = openInput(module, &input, &config,
1280 &device, address, source, flags);
1281 reply->writeInt32((int32_t) status);
1282 if (status == NO_ERROR) {
1283 reply->writeInt32((int32_t) input);
1284 reply->write(&config, sizeof(audio_config_t));
1285 reply->writeInt32(device);
1286 }
1287 return NO_ERROR;
1288 } break;
1289 case CLOSE_INPUT: {
1290 CHECK_INTERFACE(IAudioFlinger, data, reply);
1291 reply->writeInt32(closeInput((audio_io_handle_t) data.readInt32()));
1292 return NO_ERROR;
1293 } break;
1294 case INVALIDATE_STREAM: {
1295 CHECK_INTERFACE(IAudioFlinger, data, reply);
1296 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32();
1297 reply->writeInt32(invalidateStream(stream));
1298 return NO_ERROR;
1299 } break;
1300 case SET_VOICE_VOLUME: {
1301 CHECK_INTERFACE(IAudioFlinger, data, reply);
1302 float volume = data.readFloat();
1303 reply->writeInt32( setVoiceVolume(volume) );
1304 return NO_ERROR;
1305 } break;
1306 case GET_RENDER_POSITION: {
1307 CHECK_INTERFACE(IAudioFlinger, data, reply);
1308 audio_io_handle_t output = (audio_io_handle_t) data.readInt32();
1309 uint32_t halFrames = 0;
1310 uint32_t dspFrames = 0;
1311 status_t status = getRenderPosition(&halFrames, &dspFrames, output);
1312 reply->writeInt32(status);
1313 if (status == NO_ERROR) {
1314 reply->writeInt32(halFrames);
1315 reply->writeInt32(dspFrames);
1316 }
1317 return NO_ERROR;
1318 }
1319 case GET_INPUT_FRAMES_LOST: {
1320 CHECK_INTERFACE(IAudioFlinger, data, reply);
1321 audio_io_handle_t ioHandle = (audio_io_handle_t) data.readInt32();
1322 reply->writeInt32((int32_t) getInputFramesLost(ioHandle));
1323 return NO_ERROR;
1324 } break;
1325 case NEW_AUDIO_UNIQUE_ID: {
1326 CHECK_INTERFACE(IAudioFlinger, data, reply);
1327 reply->writeInt32(newAudioUniqueId((audio_unique_id_use_t) data.readInt32()));
1328 return NO_ERROR;
1329 } break;
1330 case ACQUIRE_AUDIO_SESSION_ID: {
1331 CHECK_INTERFACE(IAudioFlinger, data, reply);
1332 audio_session_t audioSession = (audio_session_t) data.readInt32();
1333 const pid_t pid = (pid_t)data.readInt32();
1334 const uid_t uid = (uid_t)data.readInt32();
1335 acquireAudioSessionId(audioSession, pid, uid);
1336 return NO_ERROR;
1337 } break;
1338 case RELEASE_AUDIO_SESSION_ID: {
1339 CHECK_INTERFACE(IAudioFlinger, data, reply);
1340 audio_session_t audioSession = (audio_session_t) data.readInt32();
1341 int pid = data.readInt32();
1342 releaseAudioSessionId(audioSession, pid);
1343 return NO_ERROR;
1344 } break;
1345 case QUERY_NUM_EFFECTS: {
1346 CHECK_INTERFACE(IAudioFlinger, data, reply);
1347 uint32_t numEffects = 0;
1348 status_t status = queryNumberEffects(&numEffects);
1349 reply->writeInt32(status);
1350 if (status == NO_ERROR) {
1351 reply->writeInt32((int32_t)numEffects);
1352 }
1353 return NO_ERROR;
1354 }
1355 case QUERY_EFFECT: {
1356 CHECK_INTERFACE(IAudioFlinger, data, reply);
1357 effect_descriptor_t desc = {};
1358 status_t status = queryEffect(data.readInt32(), &desc);
1359 reply->writeInt32(status);
1360 if (status == NO_ERROR) {
1361 reply->write(&desc, sizeof(effect_descriptor_t));
1362 }
1363 return NO_ERROR;
1364 }
1365 case GET_EFFECT_DESCRIPTOR: {
1366 CHECK_INTERFACE(IAudioFlinger, data, reply);
1367 effect_uuid_t uuid = {};
1368 if (data.read(&uuid, sizeof(effect_uuid_t)) != NO_ERROR) {
1369 android_errorWriteLog(0x534e4554, "139417189");
1370 }
1371 effect_uuid_t type = {};
1372 if (data.read(&type, sizeof(effect_uuid_t)) != NO_ERROR) {
1373 android_errorWriteLog(0x534e4554, "139417189");
1374 }
1375 uint32_t preferredTypeFlag = data.readUint32();
1376 effect_descriptor_t desc = {};
1377 status_t status = getEffectDescriptor(&uuid, &type, preferredTypeFlag, &desc);
1378 reply->writeInt32(status);
1379 if (status == NO_ERROR) {
1380 reply->write(&desc, sizeof(effect_descriptor_t));
1381 }
1382 return NO_ERROR;
1383 }
1384 case CREATE_EFFECT: {
1385 CHECK_INTERFACE(IAudioFlinger, data, reply);
1386 effect_descriptor_t desc = {};
1387 if (data.read(&desc, sizeof(effect_descriptor_t)) != NO_ERROR) {
1388 ALOGE("b/23905951");
1389 }
1390 sp<IEffectClient> client = interface_cast<IEffectClient>(data.readStrongBinder());
1391 int32_t priority = data.readInt32();
1392 audio_io_handle_t output = (audio_io_handle_t) data.readInt32();
1393 audio_session_t sessionId = (audio_session_t) data.readInt32();
1394 AudioDeviceTypeAddr device;
1395 status_t status = NO_ERROR;
1396 if ((status = data.readParcelable(&device)) != NO_ERROR) {
1397 return status;
1398 }
1399 const String16 opPackageName = data.readString16();
1400 pid_t pid = (pid_t)data.readInt32();
1401 bool probe = data.readInt32() == 1;
1402
1403 int id = 0;
1404 int enabled = 0;
1405
1406 sp<IEffect> effect = createEffect(&desc, client, priority, output, sessionId, device,
1407 opPackageName, pid, probe, &status, &id, &enabled);
1408 reply->writeInt32(status);
1409 reply->writeInt32(id);
1410 reply->writeInt32(enabled);
1411 reply->writeStrongBinder(IInterface::asBinder(effect));
1412 reply->write(&desc, sizeof(effect_descriptor_t));
1413 return NO_ERROR;
1414 } break;
1415 case MOVE_EFFECTS: {
1416 CHECK_INTERFACE(IAudioFlinger, data, reply);
1417 audio_session_t session = (audio_session_t) data.readInt32();
1418 audio_io_handle_t srcOutput = (audio_io_handle_t) data.readInt32();
1419 audio_io_handle_t dstOutput = (audio_io_handle_t) data.readInt32();
1420 reply->writeInt32(moveEffects(session, srcOutput, dstOutput));
1421 return NO_ERROR;
1422 } break;
1423 case SET_EFFECT_SUSPENDED: {
1424 CHECK_INTERFACE(IAudioFlinger, data, reply);
1425 int effectId = data.readInt32();
1426 audio_session_t sessionId = (audio_session_t) data.readInt32();
1427 bool suspended = data.readInt32() == 1;
1428 setEffectSuspended(effectId, sessionId, suspended);
1429 return NO_ERROR;
1430 } break;
1431 case LOAD_HW_MODULE: {
1432 CHECK_INTERFACE(IAudioFlinger, data, reply);
1433 reply->writeInt32(loadHwModule(data.readCString()));
1434 return NO_ERROR;
1435 } break;
1436 case GET_PRIMARY_OUTPUT_SAMPLING_RATE: {
1437 CHECK_INTERFACE(IAudioFlinger, data, reply);
1438 reply->writeInt32(getPrimaryOutputSamplingRate());
1439 return NO_ERROR;
1440 } break;
1441 case GET_PRIMARY_OUTPUT_FRAME_COUNT: {
1442 CHECK_INTERFACE(IAudioFlinger, data, reply);
1443 reply->writeInt64(getPrimaryOutputFrameCount());
1444 return NO_ERROR;
1445 } break;
1446 case SET_LOW_RAM_DEVICE: {
1447 CHECK_INTERFACE(IAudioFlinger, data, reply);
1448 int32_t isLowRamDevice;
1449 int64_t totalMemory;
1450 const status_t status =
1451 data.readInt32(&isLowRamDevice) ?:
1452 data.readInt64(&totalMemory) ?:
1453 setLowRamDevice(isLowRamDevice != 0, totalMemory);
1454 (void)reply->writeInt32(status);
1455 return NO_ERROR;
1456 } break;
1457 case LIST_AUDIO_PORTS: {
1458 CHECK_INTERFACE(IAudioFlinger, data, reply);
1459 unsigned int numPortsReq = data.readInt32();
1460 if (numPortsReq > MAX_ITEMS_PER_LIST) {
1461 numPortsReq = MAX_ITEMS_PER_LIST;
1462 }
1463 unsigned int numPorts = numPortsReq;
1464 struct audio_port *ports =
1465 (struct audio_port *)calloc(numPortsReq,
1466 sizeof(struct audio_port));
1467 if (ports == NULL) {
1468 reply->writeInt32(NO_MEMORY);
1469 reply->writeInt32(0);
1470 return NO_ERROR;
1471 }
1472 status_t status = listAudioPorts(&numPorts, ports);
1473 reply->writeInt32(status);
1474 reply->writeInt32(numPorts);
1475 if (status == NO_ERROR) {
1476 if (numPortsReq > numPorts) {
1477 numPortsReq = numPorts;
1478 }
1479 reply->write(ports, numPortsReq * sizeof(struct audio_port));
1480 }
1481 free(ports);
1482 return NO_ERROR;
1483 } break;
1484 case GET_AUDIO_PORT: {
1485 CHECK_INTERFACE(IAudioFlinger, data, reply);
1486 struct audio_port port = {};
1487 status_t status = data.read(&port, sizeof(struct audio_port));
1488 if (status != NO_ERROR) {
1489 ALOGE("b/23905951");
1490 return status;
1491 }
1492 status = AudioSanitizer::sanitizeAudioPort(&port);
1493 if (status == NO_ERROR) {
1494 status = getAudioPort(&port);
1495 }
1496 reply->writeInt32(status);
1497 if (status == NO_ERROR) {
1498 reply->write(&port, sizeof(struct audio_port));
1499 }
1500 return NO_ERROR;
1501 } break;
1502 case CREATE_AUDIO_PATCH: {
1503 CHECK_INTERFACE(IAudioFlinger, data, reply);
1504 struct audio_patch patch;
1505 status_t status = data.read(&patch, sizeof(struct audio_patch));
1506 if (status != NO_ERROR) {
1507 return status;
1508 }
1509 audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE;
1510 status = data.read(&handle, sizeof(audio_patch_handle_t));
1511 if (status != NO_ERROR) {
1512 ALOGE("b/23905951");
1513 return status;
1514 }
1515 status = AudioSanitizer::sanitizeAudioPatch(&patch);
1516 if (status == NO_ERROR) {
1517 status = createAudioPatch(&patch, &handle);
1518 }
1519 reply->writeInt32(status);
1520 if (status == NO_ERROR) {
1521 reply->write(&handle, sizeof(audio_patch_handle_t));
1522 }
1523 return NO_ERROR;
1524 } break;
1525 case RELEASE_AUDIO_PATCH: {
1526 CHECK_INTERFACE(IAudioFlinger, data, reply);
1527 audio_patch_handle_t handle;
1528 data.read(&handle, sizeof(audio_patch_handle_t));
1529 status_t status = releaseAudioPatch(handle);
1530 reply->writeInt32(status);
1531 return NO_ERROR;
1532 } break;
1533 case LIST_AUDIO_PATCHES: {
1534 CHECK_INTERFACE(IAudioFlinger, data, reply);
1535 unsigned int numPatchesReq = data.readInt32();
1536 if (numPatchesReq > MAX_ITEMS_PER_LIST) {
1537 numPatchesReq = MAX_ITEMS_PER_LIST;
1538 }
1539 unsigned int numPatches = numPatchesReq;
1540 struct audio_patch *patches =
1541 (struct audio_patch *)calloc(numPatchesReq,
1542 sizeof(struct audio_patch));
1543 if (patches == NULL) {
1544 reply->writeInt32(NO_MEMORY);
1545 reply->writeInt32(0);
1546 return NO_ERROR;
1547 }
1548 status_t status = listAudioPatches(&numPatches, patches);
1549 reply->writeInt32(status);
1550 reply->writeInt32(numPatches);
1551 if (status == NO_ERROR) {
1552 if (numPatchesReq > numPatches) {
1553 numPatchesReq = numPatches;
1554 }
1555 reply->write(patches, numPatchesReq * sizeof(struct audio_patch));
1556 }
1557 free(patches);
1558 return NO_ERROR;
1559 } break;
1560 case SET_AUDIO_PORT_CONFIG: {
1561 CHECK_INTERFACE(IAudioFlinger, data, reply);
1562 struct audio_port_config config;
1563 status_t status = data.read(&config, sizeof(struct audio_port_config));
1564 if (status != NO_ERROR) {
1565 return status;
1566 }
1567 status = AudioSanitizer::sanitizeAudioPortConfig(&config);
1568 if (status == NO_ERROR) {
1569 status = setAudioPortConfig(&config);
1570 }
1571 reply->writeInt32(status);
1572 return NO_ERROR;
1573 } break;
1574 case GET_AUDIO_HW_SYNC_FOR_SESSION: {
1575 CHECK_INTERFACE(IAudioFlinger, data, reply);
1576 reply->writeInt32(getAudioHwSyncForSession((audio_session_t) data.readInt32()));
1577 return NO_ERROR;
1578 } break;
1579 case SYSTEM_READY: {
1580 CHECK_INTERFACE(IAudioFlinger, data, reply);
1581 systemReady();
1582 return NO_ERROR;
1583 } break;
1584 case FRAME_COUNT_HAL: {
1585 CHECK_INTERFACE(IAudioFlinger, data, reply);
1586 reply->writeInt64( frameCountHAL((audio_io_handle_t) data.readInt32()) );
1587 return NO_ERROR;
1588 } break;
1589 case GET_MICROPHONES: {
1590 CHECK_INTERFACE(IAudioFlinger, data, reply);
1591 std::vector<media::MicrophoneInfo> microphones;
1592 status_t status = getMicrophones(µphones);
1593 reply->writeInt32(status);
1594 if (status == NO_ERROR) {
1595 reply->writeParcelableVector(microphones);
1596 }
1597 return NO_ERROR;
1598 }
1599 case SET_AUDIO_HAL_PIDS: {
1600 CHECK_INTERFACE(IAudioFlinger, data, reply);
1601 std::vector<pid_t> pids;
1602 int32_t size;
1603 status_t status = data.readInt32(&size);
1604 if (status != NO_ERROR) {
1605 return status;
1606 }
1607 if (size < 0) {
1608 return BAD_VALUE;
1609 }
1610 if (size > MAX_ITEMS_PER_LIST) {
1611 size = MAX_ITEMS_PER_LIST;
1612 }
1613 for (int32_t i = 0; i < size; i++) {
1614 int32_t pid;
1615 status = data.readInt32(&pid);
1616 if (status != NO_ERROR) {
1617 return status;
1618 }
1619 pids.push_back(pid);
1620 }
1621 reply->writeInt32(setAudioHalPids(pids));
1622 return NO_ERROR;
1623 }
1624 default:
1625 return BBinder::onTransact(code, data, reply, flags);
1626 }
1627 }
1628
1629 // ----------------------------------------------------------------------------
1630
1631 } // namespace android
1632