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