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