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 <media/IAudioFlinger.h>
28
29 namespace android {
30
31 enum {
32 CREATE_TRACK = IBinder::FIRST_CALL_TRANSACTION,
33 OPEN_RECORD,
34 SAMPLE_RATE,
35 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 SET_STREAM_OUTPUT,
62 SET_VOICE_VOLUME,
63 GET_RENDER_POSITION,
64 GET_INPUT_FRAMES_LOST,
65 NEW_AUDIO_SESSION_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 };
75
76 class BpAudioFlinger : public BpInterface<IAudioFlinger>
77 {
78 public:
BpAudioFlinger(const sp<IBinder> & impl)79 BpAudioFlinger(const sp<IBinder>& impl)
80 : BpInterface<IAudioFlinger>(impl)
81 {
82 }
83
createTrack(pid_t pid,audio_stream_type_t streamType,uint32_t sampleRate,audio_format_t format,uint32_t channelMask,int frameCount,track_flags_t flags,const sp<IMemory> & sharedBuffer,audio_io_handle_t output,pid_t tid,int * sessionId,status_t * status)84 virtual sp<IAudioTrack> createTrack(
85 pid_t pid,
86 audio_stream_type_t streamType,
87 uint32_t sampleRate,
88 audio_format_t format,
89 uint32_t channelMask,
90 int frameCount,
91 track_flags_t flags,
92 const sp<IMemory>& sharedBuffer,
93 audio_io_handle_t output,
94 pid_t tid,
95 int *sessionId,
96 status_t *status)
97 {
98 Parcel data, reply;
99 sp<IAudioTrack> track;
100 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
101 data.writeInt32(pid);
102 data.writeInt32((int32_t) streamType);
103 data.writeInt32(sampleRate);
104 data.writeInt32(format);
105 data.writeInt32(channelMask);
106 data.writeInt32(frameCount);
107 data.writeInt32((int32_t) flags);
108 data.writeStrongBinder(sharedBuffer->asBinder());
109 data.writeInt32((int32_t) output);
110 data.writeInt32((int32_t) tid);
111 int lSessionId = 0;
112 if (sessionId != NULL) {
113 lSessionId = *sessionId;
114 }
115 data.writeInt32(lSessionId);
116 status_t lStatus = remote()->transact(CREATE_TRACK, data, &reply);
117 if (lStatus != NO_ERROR) {
118 ALOGE("createTrack error: %s", strerror(-lStatus));
119 } else {
120 lSessionId = reply.readInt32();
121 if (sessionId != NULL) {
122 *sessionId = lSessionId;
123 }
124 lStatus = reply.readInt32();
125 track = interface_cast<IAudioTrack>(reply.readStrongBinder());
126 }
127 if (status) {
128 *status = lStatus;
129 }
130 return track;
131 }
132
openRecord(pid_t pid,audio_io_handle_t input,uint32_t sampleRate,audio_format_t format,uint32_t channelMask,int frameCount,track_flags_t flags,int * sessionId,status_t * status)133 virtual sp<IAudioRecord> openRecord(
134 pid_t pid,
135 audio_io_handle_t input,
136 uint32_t sampleRate,
137 audio_format_t format,
138 uint32_t channelMask,
139 int frameCount,
140 track_flags_t flags,
141 int *sessionId,
142 status_t *status)
143 {
144 Parcel data, reply;
145 sp<IAudioRecord> record;
146 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
147 data.writeInt32(pid);
148 data.writeInt32((int32_t) input);
149 data.writeInt32(sampleRate);
150 data.writeInt32(format);
151 data.writeInt32(channelMask);
152 data.writeInt32(frameCount);
153 data.writeInt32(flags);
154 int lSessionId = 0;
155 if (sessionId != NULL) {
156 lSessionId = *sessionId;
157 }
158 data.writeInt32(lSessionId);
159 status_t lStatus = remote()->transact(OPEN_RECORD, data, &reply);
160 if (lStatus != NO_ERROR) {
161 ALOGE("openRecord error: %s", strerror(-lStatus));
162 } else {
163 lSessionId = reply.readInt32();
164 if (sessionId != NULL) {
165 *sessionId = lSessionId;
166 }
167 lStatus = reply.readInt32();
168 record = interface_cast<IAudioRecord>(reply.readStrongBinder());
169 }
170 if (status) {
171 *status = lStatus;
172 }
173 return record;
174 }
175
sampleRate(audio_io_handle_t output) const176 virtual uint32_t sampleRate(audio_io_handle_t output) const
177 {
178 Parcel data, reply;
179 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
180 data.writeInt32((int32_t) output);
181 remote()->transact(SAMPLE_RATE, data, &reply);
182 return reply.readInt32();
183 }
184
channelCount(audio_io_handle_t output) const185 virtual int channelCount(audio_io_handle_t output) const
186 {
187 Parcel data, reply;
188 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
189 data.writeInt32((int32_t) output);
190 remote()->transact(CHANNEL_COUNT, data, &reply);
191 return reply.readInt32();
192 }
193
format(audio_io_handle_t output) const194 virtual audio_format_t format(audio_io_handle_t output) const
195 {
196 Parcel data, reply;
197 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
198 data.writeInt32((int32_t) output);
199 remote()->transact(FORMAT, data, &reply);
200 return (audio_format_t) reply.readInt32();
201 }
202
frameCount(audio_io_handle_t output) const203 virtual size_t frameCount(audio_io_handle_t output) const
204 {
205 Parcel data, reply;
206 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
207 data.writeInt32((int32_t) output);
208 remote()->transact(FRAME_COUNT, data, &reply);
209 return reply.readInt32();
210 }
211
latency(audio_io_handle_t output) const212 virtual uint32_t latency(audio_io_handle_t output) const
213 {
214 Parcel data, reply;
215 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
216 data.writeInt32((int32_t) output);
217 remote()->transact(LATENCY, data, &reply);
218 return reply.readInt32();
219 }
220
setMasterVolume(float value)221 virtual status_t setMasterVolume(float value)
222 {
223 Parcel data, reply;
224 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
225 data.writeFloat(value);
226 remote()->transact(SET_MASTER_VOLUME, data, &reply);
227 return reply.readInt32();
228 }
229
setMasterMute(bool muted)230 virtual status_t setMasterMute(bool muted)
231 {
232 Parcel data, reply;
233 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
234 data.writeInt32(muted);
235 remote()->transact(SET_MASTER_MUTE, data, &reply);
236 return reply.readInt32();
237 }
238
masterVolume() const239 virtual float masterVolume() const
240 {
241 Parcel data, reply;
242 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
243 remote()->transact(MASTER_VOLUME, data, &reply);
244 return reply.readFloat();
245 }
246
masterMute() const247 virtual bool masterMute() const
248 {
249 Parcel data, reply;
250 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
251 remote()->transact(MASTER_MUTE, data, &reply);
252 return reply.readInt32();
253 }
254
setStreamVolume(audio_stream_type_t stream,float value,audio_io_handle_t output)255 virtual status_t setStreamVolume(audio_stream_type_t stream, float value,
256 audio_io_handle_t output)
257 {
258 Parcel data, reply;
259 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
260 data.writeInt32((int32_t) stream);
261 data.writeFloat(value);
262 data.writeInt32((int32_t) output);
263 remote()->transact(SET_STREAM_VOLUME, data, &reply);
264 return reply.readInt32();
265 }
266
setStreamMute(audio_stream_type_t stream,bool muted)267 virtual status_t setStreamMute(audio_stream_type_t stream, bool muted)
268 {
269 Parcel data, reply;
270 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
271 data.writeInt32((int32_t) stream);
272 data.writeInt32(muted);
273 remote()->transact(SET_STREAM_MUTE, data, &reply);
274 return reply.readInt32();
275 }
276
streamVolume(audio_stream_type_t stream,audio_io_handle_t output) const277 virtual float streamVolume(audio_stream_type_t stream, audio_io_handle_t output) const
278 {
279 Parcel data, reply;
280 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
281 data.writeInt32((int32_t) stream);
282 data.writeInt32((int32_t) output);
283 remote()->transact(STREAM_VOLUME, data, &reply);
284 return reply.readFloat();
285 }
286
streamMute(audio_stream_type_t stream) const287 virtual bool streamMute(audio_stream_type_t stream) const
288 {
289 Parcel data, reply;
290 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
291 data.writeInt32((int32_t) stream);
292 remote()->transact(STREAM_MUTE, data, &reply);
293 return reply.readInt32();
294 }
295
setMode(audio_mode_t mode)296 virtual status_t setMode(audio_mode_t mode)
297 {
298 Parcel data, reply;
299 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
300 data.writeInt32(mode);
301 remote()->transact(SET_MODE, data, &reply);
302 return reply.readInt32();
303 }
304
setMicMute(bool state)305 virtual status_t setMicMute(bool state)
306 {
307 Parcel data, reply;
308 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
309 data.writeInt32(state);
310 remote()->transact(SET_MIC_MUTE, data, &reply);
311 return reply.readInt32();
312 }
313
getMicMute() const314 virtual bool getMicMute() const
315 {
316 Parcel data, reply;
317 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
318 remote()->transact(GET_MIC_MUTE, data, &reply);
319 return reply.readInt32();
320 }
321
setParameters(audio_io_handle_t ioHandle,const String8 & keyValuePairs)322 virtual status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs)
323 {
324 Parcel data, reply;
325 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
326 data.writeInt32((int32_t) ioHandle);
327 data.writeString8(keyValuePairs);
328 remote()->transact(SET_PARAMETERS, data, &reply);
329 return reply.readInt32();
330 }
331
getParameters(audio_io_handle_t ioHandle,const String8 & keys) const332 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) const
333 {
334 Parcel data, reply;
335 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
336 data.writeInt32((int32_t) ioHandle);
337 data.writeString8(keys);
338 remote()->transact(GET_PARAMETERS, data, &reply);
339 return reply.readString8();
340 }
341
registerClient(const sp<IAudioFlingerClient> & client)342 virtual void registerClient(const sp<IAudioFlingerClient>& client)
343 {
344 Parcel data, reply;
345 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
346 data.writeStrongBinder(client->asBinder());
347 remote()->transact(REGISTER_CLIENT, data, &reply);
348 }
349
getInputBufferSize(uint32_t sampleRate,audio_format_t format,int channelCount) const350 virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, int channelCount) const
351 {
352 Parcel data, reply;
353 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
354 data.writeInt32(sampleRate);
355 data.writeInt32(format);
356 data.writeInt32(channelCount);
357 remote()->transact(GET_INPUTBUFFERSIZE, data, &reply);
358 return reply.readInt32();
359 }
360
openOutput(audio_module_handle_t module,audio_devices_t * pDevices,uint32_t * pSamplingRate,audio_format_t * pFormat,audio_channel_mask_t * pChannelMask,uint32_t * pLatencyMs,audio_output_flags_t flags)361 virtual audio_io_handle_t openOutput(audio_module_handle_t module,
362 audio_devices_t *pDevices,
363 uint32_t *pSamplingRate,
364 audio_format_t *pFormat,
365 audio_channel_mask_t *pChannelMask,
366 uint32_t *pLatencyMs,
367 audio_output_flags_t flags)
368 {
369 Parcel data, reply;
370 audio_devices_t devices = pDevices ? *pDevices : (audio_devices_t)0;
371 uint32_t samplingRate = pSamplingRate ? *pSamplingRate : 0;
372 audio_format_t format = pFormat ? *pFormat : AUDIO_FORMAT_DEFAULT;
373 audio_channel_mask_t channelMask = pChannelMask ? *pChannelMask : (audio_channel_mask_t)0;
374 uint32_t latency = pLatencyMs ? *pLatencyMs : 0;
375
376 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
377 data.writeInt32(module);
378 data.writeInt32(devices);
379 data.writeInt32(samplingRate);
380 data.writeInt32(format);
381 data.writeInt32(channelMask);
382 data.writeInt32(latency);
383 data.writeInt32((int32_t) flags);
384 remote()->transact(OPEN_OUTPUT, data, &reply);
385 audio_io_handle_t output = (audio_io_handle_t) reply.readInt32();
386 ALOGV("openOutput() returned output, %d", output);
387 devices = (audio_devices_t)reply.readInt32();
388 if (pDevices) *pDevices = devices;
389 samplingRate = reply.readInt32();
390 if (pSamplingRate) *pSamplingRate = samplingRate;
391 format = (audio_format_t) reply.readInt32();
392 if (pFormat) *pFormat = format;
393 channelMask = (audio_channel_mask_t)reply.readInt32();
394 if (pChannelMask) *pChannelMask = channelMask;
395 latency = reply.readInt32();
396 if (pLatencyMs) *pLatencyMs = latency;
397 return output;
398 }
399
openDuplicateOutput(audio_io_handle_t output1,audio_io_handle_t output2)400 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1,
401 audio_io_handle_t output2)
402 {
403 Parcel data, reply;
404 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
405 data.writeInt32((int32_t) output1);
406 data.writeInt32((int32_t) output2);
407 remote()->transact(OPEN_DUPLICATE_OUTPUT, data, &reply);
408 return (audio_io_handle_t) reply.readInt32();
409 }
410
closeOutput(audio_io_handle_t output)411 virtual status_t closeOutput(audio_io_handle_t output)
412 {
413 Parcel data, reply;
414 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
415 data.writeInt32((int32_t) output);
416 remote()->transact(CLOSE_OUTPUT, data, &reply);
417 return reply.readInt32();
418 }
419
suspendOutput(audio_io_handle_t output)420 virtual status_t suspendOutput(audio_io_handle_t output)
421 {
422 Parcel data, reply;
423 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
424 data.writeInt32((int32_t) output);
425 remote()->transact(SUSPEND_OUTPUT, data, &reply);
426 return reply.readInt32();
427 }
428
restoreOutput(audio_io_handle_t output)429 virtual status_t restoreOutput(audio_io_handle_t output)
430 {
431 Parcel data, reply;
432 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
433 data.writeInt32((int32_t) output);
434 remote()->transact(RESTORE_OUTPUT, data, &reply);
435 return reply.readInt32();
436 }
437
openInput(audio_module_handle_t module,audio_devices_t * pDevices,uint32_t * pSamplingRate,audio_format_t * pFormat,audio_channel_mask_t * pChannelMask)438 virtual audio_io_handle_t openInput(audio_module_handle_t module,
439 audio_devices_t *pDevices,
440 uint32_t *pSamplingRate,
441 audio_format_t *pFormat,
442 audio_channel_mask_t *pChannelMask)
443 {
444 Parcel data, reply;
445 audio_devices_t devices = pDevices ? *pDevices : (audio_devices_t)0;
446 uint32_t samplingRate = pSamplingRate ? *pSamplingRate : 0;
447 audio_format_t format = pFormat ? *pFormat : AUDIO_FORMAT_DEFAULT;
448 audio_channel_mask_t channelMask = pChannelMask ? *pChannelMask : (audio_channel_mask_t)0;
449
450 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
451 data.writeInt32(module);
452 data.writeInt32(devices);
453 data.writeInt32(samplingRate);
454 data.writeInt32(format);
455 data.writeInt32(channelMask);
456 remote()->transact(OPEN_INPUT, data, &reply);
457 audio_io_handle_t input = (audio_io_handle_t) reply.readInt32();
458 devices = (audio_devices_t)reply.readInt32();
459 if (pDevices) *pDevices = devices;
460 samplingRate = reply.readInt32();
461 if (pSamplingRate) *pSamplingRate = samplingRate;
462 format = (audio_format_t) reply.readInt32();
463 if (pFormat) *pFormat = format;
464 channelMask = (audio_channel_mask_t)reply.readInt32();
465 if (pChannelMask) *pChannelMask = channelMask;
466 return input;
467 }
468
closeInput(int input)469 virtual status_t closeInput(int input)
470 {
471 Parcel data, reply;
472 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
473 data.writeInt32(input);
474 remote()->transact(CLOSE_INPUT, data, &reply);
475 return reply.readInt32();
476 }
477
setStreamOutput(audio_stream_type_t stream,audio_io_handle_t output)478 virtual status_t setStreamOutput(audio_stream_type_t stream, audio_io_handle_t output)
479 {
480 Parcel data, reply;
481 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
482 data.writeInt32((int32_t) stream);
483 data.writeInt32((int32_t) output);
484 remote()->transact(SET_STREAM_OUTPUT, data, &reply);
485 return reply.readInt32();
486 }
487
setVoiceVolume(float volume)488 virtual status_t setVoiceVolume(float volume)
489 {
490 Parcel data, reply;
491 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
492 data.writeFloat(volume);
493 remote()->transact(SET_VOICE_VOLUME, data, &reply);
494 return reply.readInt32();
495 }
496
getRenderPosition(uint32_t * halFrames,uint32_t * dspFrames,audio_io_handle_t output) const497 virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames,
498 audio_io_handle_t output) const
499 {
500 Parcel data, reply;
501 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
502 data.writeInt32((int32_t) output);
503 remote()->transact(GET_RENDER_POSITION, data, &reply);
504 status_t status = reply.readInt32();
505 if (status == NO_ERROR) {
506 uint32_t tmp = reply.readInt32();
507 if (halFrames) {
508 *halFrames = tmp;
509 }
510 tmp = reply.readInt32();
511 if (dspFrames) {
512 *dspFrames = tmp;
513 }
514 }
515 return status;
516 }
517
getInputFramesLost(audio_io_handle_t ioHandle) const518 virtual unsigned int getInputFramesLost(audio_io_handle_t ioHandle) const
519 {
520 Parcel data, reply;
521 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
522 data.writeInt32((int32_t) ioHandle);
523 remote()->transact(GET_INPUT_FRAMES_LOST, data, &reply);
524 return reply.readInt32();
525 }
526
newAudioSessionId()527 virtual int newAudioSessionId()
528 {
529 Parcel data, reply;
530 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
531 status_t status = remote()->transact(NEW_AUDIO_SESSION_ID, data, &reply);
532 int id = 0;
533 if (status == NO_ERROR) {
534 id = reply.readInt32();
535 }
536 return id;
537 }
538
acquireAudioSessionId(int audioSession)539 virtual void acquireAudioSessionId(int audioSession)
540 {
541 Parcel data, reply;
542 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
543 data.writeInt32(audioSession);
544 remote()->transact(ACQUIRE_AUDIO_SESSION_ID, data, &reply);
545 }
546
releaseAudioSessionId(int audioSession)547 virtual void releaseAudioSessionId(int audioSession)
548 {
549 Parcel data, reply;
550 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
551 data.writeInt32(audioSession);
552 remote()->transact(RELEASE_AUDIO_SESSION_ID, data, &reply);
553 }
554
queryNumberEffects(uint32_t * numEffects) const555 virtual status_t queryNumberEffects(uint32_t *numEffects) const
556 {
557 Parcel data, reply;
558 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
559 status_t status = remote()->transact(QUERY_NUM_EFFECTS, data, &reply);
560 if (status != NO_ERROR) {
561 return status;
562 }
563 status = reply.readInt32();
564 if (status != NO_ERROR) {
565 return status;
566 }
567 if (numEffects != NULL) {
568 *numEffects = (uint32_t)reply.readInt32();
569 }
570 return NO_ERROR;
571 }
572
queryEffect(uint32_t index,effect_descriptor_t * pDescriptor) const573 virtual status_t queryEffect(uint32_t index, effect_descriptor_t *pDescriptor) const
574 {
575 if (pDescriptor == NULL) {
576 return BAD_VALUE;
577 }
578 Parcel data, reply;
579 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
580 data.writeInt32(index);
581 status_t status = remote()->transact(QUERY_EFFECT, data, &reply);
582 if (status != NO_ERROR) {
583 return status;
584 }
585 status = reply.readInt32();
586 if (status != NO_ERROR) {
587 return status;
588 }
589 reply.read(pDescriptor, sizeof(effect_descriptor_t));
590 return NO_ERROR;
591 }
592
getEffectDescriptor(const effect_uuid_t * pUuid,effect_descriptor_t * pDescriptor) const593 virtual status_t getEffectDescriptor(const effect_uuid_t *pUuid,
594 effect_descriptor_t *pDescriptor) const
595 {
596 if (pUuid == NULL || pDescriptor == NULL) {
597 return BAD_VALUE;
598 }
599 Parcel data, reply;
600 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
601 data.write(pUuid, sizeof(effect_uuid_t));
602 status_t status = remote()->transact(GET_EFFECT_DESCRIPTOR, data, &reply);
603 if (status != NO_ERROR) {
604 return status;
605 }
606 status = reply.readInt32();
607 if (status != NO_ERROR) {
608 return status;
609 }
610 reply.read(pDescriptor, sizeof(effect_descriptor_t));
611 return NO_ERROR;
612 }
613
createEffect(pid_t pid,effect_descriptor_t * pDesc,const sp<IEffectClient> & client,int32_t priority,audio_io_handle_t output,int sessionId,status_t * status,int * id,int * enabled)614 virtual sp<IEffect> createEffect(pid_t pid,
615 effect_descriptor_t *pDesc,
616 const sp<IEffectClient>& client,
617 int32_t priority,
618 audio_io_handle_t output,
619 int sessionId,
620 status_t *status,
621 int *id,
622 int *enabled)
623 {
624 Parcel data, reply;
625 sp<IEffect> effect;
626
627 if (pDesc == NULL) {
628 return effect;
629 if (status) {
630 *status = BAD_VALUE;
631 }
632 }
633
634 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
635 data.writeInt32(pid);
636 data.write(pDesc, sizeof(effect_descriptor_t));
637 data.writeStrongBinder(client->asBinder());
638 data.writeInt32(priority);
639 data.writeInt32((int32_t) output);
640 data.writeInt32(sessionId);
641
642 status_t lStatus = remote()->transact(CREATE_EFFECT, data, &reply);
643 if (lStatus != NO_ERROR) {
644 ALOGE("createEffect error: %s", strerror(-lStatus));
645 } else {
646 lStatus = reply.readInt32();
647 int tmp = reply.readInt32();
648 if (id) {
649 *id = tmp;
650 }
651 tmp = reply.readInt32();
652 if (enabled != NULL) {
653 *enabled = tmp;
654 }
655 effect = interface_cast<IEffect>(reply.readStrongBinder());
656 reply.read(pDesc, sizeof(effect_descriptor_t));
657 }
658 if (status) {
659 *status = lStatus;
660 }
661
662 return effect;
663 }
664
moveEffects(int session,audio_io_handle_t srcOutput,audio_io_handle_t dstOutput)665 virtual status_t moveEffects(int session, audio_io_handle_t srcOutput,
666 audio_io_handle_t dstOutput)
667 {
668 Parcel data, reply;
669 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
670 data.writeInt32(session);
671 data.writeInt32((int32_t) srcOutput);
672 data.writeInt32((int32_t) dstOutput);
673 remote()->transact(MOVE_EFFECTS, data, &reply);
674 return reply.readInt32();
675 }
676
loadHwModule(const char * name)677 virtual audio_module_handle_t loadHwModule(const char *name)
678 {
679 Parcel data, reply;
680 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
681 data.writeCString(name);
682 remote()->transact(LOAD_HW_MODULE, data, &reply);
683 return (audio_module_handle_t) reply.readInt32();
684 }
685 };
686
687 IMPLEMENT_META_INTERFACE(AudioFlinger, "android.media.IAudioFlinger");
688
689 // ----------------------------------------------------------------------
690
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)691 status_t BnAudioFlinger::onTransact(
692 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
693 {
694 switch (code) {
695 case CREATE_TRACK: {
696 CHECK_INTERFACE(IAudioFlinger, data, reply);
697 pid_t pid = data.readInt32();
698 int streamType = data.readInt32();
699 uint32_t sampleRate = data.readInt32();
700 audio_format_t format = (audio_format_t) data.readInt32();
701 int channelCount = data.readInt32();
702 size_t bufferCount = data.readInt32();
703 track_flags_t flags = (track_flags_t) data.readInt32();
704 sp<IMemory> buffer = interface_cast<IMemory>(data.readStrongBinder());
705 audio_io_handle_t output = (audio_io_handle_t) data.readInt32();
706 pid_t tid = (pid_t) data.readInt32();
707 int sessionId = data.readInt32();
708 status_t status;
709 sp<IAudioTrack> track = createTrack(pid,
710 (audio_stream_type_t) streamType, sampleRate, format,
711 channelCount, bufferCount, flags, buffer, output, tid, &sessionId, &status);
712 reply->writeInt32(sessionId);
713 reply->writeInt32(status);
714 reply->writeStrongBinder(track->asBinder());
715 return NO_ERROR;
716 } break;
717 case OPEN_RECORD: {
718 CHECK_INTERFACE(IAudioFlinger, data, reply);
719 pid_t pid = data.readInt32();
720 audio_io_handle_t input = (audio_io_handle_t) data.readInt32();
721 uint32_t sampleRate = data.readInt32();
722 audio_format_t format = (audio_format_t) data.readInt32();
723 int channelCount = data.readInt32();
724 size_t bufferCount = data.readInt32();
725 track_flags_t flags = (track_flags_t) data.readInt32();
726 int sessionId = data.readInt32();
727 status_t status;
728 sp<IAudioRecord> record = openRecord(pid, input,
729 sampleRate, format, channelCount, bufferCount, flags, &sessionId, &status);
730 reply->writeInt32(sessionId);
731 reply->writeInt32(status);
732 reply->writeStrongBinder(record->asBinder());
733 return NO_ERROR;
734 } break;
735 case SAMPLE_RATE: {
736 CHECK_INTERFACE(IAudioFlinger, data, reply);
737 reply->writeInt32( sampleRate((audio_io_handle_t) data.readInt32()) );
738 return NO_ERROR;
739 } break;
740 case CHANNEL_COUNT: {
741 CHECK_INTERFACE(IAudioFlinger, data, reply);
742 reply->writeInt32( channelCount((audio_io_handle_t) data.readInt32()) );
743 return NO_ERROR;
744 } break;
745 case FORMAT: {
746 CHECK_INTERFACE(IAudioFlinger, data, reply);
747 reply->writeInt32( format((audio_io_handle_t) data.readInt32()) );
748 return NO_ERROR;
749 } break;
750 case FRAME_COUNT: {
751 CHECK_INTERFACE(IAudioFlinger, data, reply);
752 reply->writeInt32( frameCount((audio_io_handle_t) data.readInt32()) );
753 return NO_ERROR;
754 } break;
755 case LATENCY: {
756 CHECK_INTERFACE(IAudioFlinger, data, reply);
757 reply->writeInt32( latency((audio_io_handle_t) data.readInt32()) );
758 return NO_ERROR;
759 } break;
760 case SET_MASTER_VOLUME: {
761 CHECK_INTERFACE(IAudioFlinger, data, reply);
762 reply->writeInt32( setMasterVolume(data.readFloat()) );
763 return NO_ERROR;
764 } break;
765 case SET_MASTER_MUTE: {
766 CHECK_INTERFACE(IAudioFlinger, data, reply);
767 reply->writeInt32( setMasterMute(data.readInt32()) );
768 return NO_ERROR;
769 } break;
770 case MASTER_VOLUME: {
771 CHECK_INTERFACE(IAudioFlinger, data, reply);
772 reply->writeFloat( masterVolume() );
773 return NO_ERROR;
774 } break;
775 case MASTER_MUTE: {
776 CHECK_INTERFACE(IAudioFlinger, data, reply);
777 reply->writeInt32( masterMute() );
778 return NO_ERROR;
779 } break;
780 case SET_STREAM_VOLUME: {
781 CHECK_INTERFACE(IAudioFlinger, data, reply);
782 int stream = data.readInt32();
783 float volume = data.readFloat();
784 audio_io_handle_t output = (audio_io_handle_t) data.readInt32();
785 reply->writeInt32( setStreamVolume((audio_stream_type_t) stream, volume, output) );
786 return NO_ERROR;
787 } break;
788 case SET_STREAM_MUTE: {
789 CHECK_INTERFACE(IAudioFlinger, data, reply);
790 int stream = data.readInt32();
791 reply->writeInt32( setStreamMute((audio_stream_type_t) stream, data.readInt32()) );
792 return NO_ERROR;
793 } break;
794 case STREAM_VOLUME: {
795 CHECK_INTERFACE(IAudioFlinger, data, reply);
796 int stream = data.readInt32();
797 int output = data.readInt32();
798 reply->writeFloat( streamVolume((audio_stream_type_t) stream, output) );
799 return NO_ERROR;
800 } break;
801 case STREAM_MUTE: {
802 CHECK_INTERFACE(IAudioFlinger, data, reply);
803 int stream = data.readInt32();
804 reply->writeInt32( streamMute((audio_stream_type_t) stream) );
805 return NO_ERROR;
806 } break;
807 case SET_MODE: {
808 CHECK_INTERFACE(IAudioFlinger, data, reply);
809 audio_mode_t mode = (audio_mode_t) data.readInt32();
810 reply->writeInt32( setMode(mode) );
811 return NO_ERROR;
812 } break;
813 case SET_MIC_MUTE: {
814 CHECK_INTERFACE(IAudioFlinger, data, reply);
815 int state = data.readInt32();
816 reply->writeInt32( setMicMute(state) );
817 return NO_ERROR;
818 } break;
819 case GET_MIC_MUTE: {
820 CHECK_INTERFACE(IAudioFlinger, data, reply);
821 reply->writeInt32( getMicMute() );
822 return NO_ERROR;
823 } break;
824 case SET_PARAMETERS: {
825 CHECK_INTERFACE(IAudioFlinger, data, reply);
826 audio_io_handle_t ioHandle = (audio_io_handle_t) data.readInt32();
827 String8 keyValuePairs(data.readString8());
828 reply->writeInt32(setParameters(ioHandle, keyValuePairs));
829 return NO_ERROR;
830 } break;
831 case GET_PARAMETERS: {
832 CHECK_INTERFACE(IAudioFlinger, data, reply);
833 audio_io_handle_t ioHandle = (audio_io_handle_t) data.readInt32();
834 String8 keys(data.readString8());
835 reply->writeString8(getParameters(ioHandle, keys));
836 return NO_ERROR;
837 } break;
838
839 case REGISTER_CLIENT: {
840 CHECK_INTERFACE(IAudioFlinger, data, reply);
841 sp<IAudioFlingerClient> client = interface_cast<IAudioFlingerClient>(data.readStrongBinder());
842 registerClient(client);
843 return NO_ERROR;
844 } break;
845 case GET_INPUTBUFFERSIZE: {
846 CHECK_INTERFACE(IAudioFlinger, data, reply);
847 uint32_t sampleRate = data.readInt32();
848 audio_format_t format = (audio_format_t) data.readInt32();
849 int channelCount = data.readInt32();
850 reply->writeInt32( getInputBufferSize(sampleRate, format, channelCount) );
851 return NO_ERROR;
852 } break;
853 case OPEN_OUTPUT: {
854 CHECK_INTERFACE(IAudioFlinger, data, reply);
855 audio_module_handle_t module = (audio_module_handle_t)data.readInt32();
856 audio_devices_t devices = (audio_devices_t)data.readInt32();
857 uint32_t samplingRate = data.readInt32();
858 audio_format_t format = (audio_format_t) data.readInt32();
859 audio_channel_mask_t channelMask = (audio_channel_mask_t)data.readInt32();
860 uint32_t latency = data.readInt32();
861 audio_output_flags_t flags = (audio_output_flags_t) data.readInt32();
862 audio_io_handle_t output = openOutput(module,
863 &devices,
864 &samplingRate,
865 &format,
866 &channelMask,
867 &latency,
868 flags);
869 ALOGV("OPEN_OUTPUT output, %p", output);
870 reply->writeInt32((int32_t) output);
871 reply->writeInt32(devices);
872 reply->writeInt32(samplingRate);
873 reply->writeInt32(format);
874 reply->writeInt32(channelMask);
875 reply->writeInt32(latency);
876 return NO_ERROR;
877 } break;
878 case OPEN_DUPLICATE_OUTPUT: {
879 CHECK_INTERFACE(IAudioFlinger, data, reply);
880 audio_io_handle_t output1 = (audio_io_handle_t) data.readInt32();
881 audio_io_handle_t output2 = (audio_io_handle_t) data.readInt32();
882 reply->writeInt32((int32_t) openDuplicateOutput(output1, output2));
883 return NO_ERROR;
884 } break;
885 case CLOSE_OUTPUT: {
886 CHECK_INTERFACE(IAudioFlinger, data, reply);
887 reply->writeInt32(closeOutput((audio_io_handle_t) data.readInt32()));
888 return NO_ERROR;
889 } break;
890 case SUSPEND_OUTPUT: {
891 CHECK_INTERFACE(IAudioFlinger, data, reply);
892 reply->writeInt32(suspendOutput((audio_io_handle_t) data.readInt32()));
893 return NO_ERROR;
894 } break;
895 case RESTORE_OUTPUT: {
896 CHECK_INTERFACE(IAudioFlinger, data, reply);
897 reply->writeInt32(restoreOutput((audio_io_handle_t) data.readInt32()));
898 return NO_ERROR;
899 } break;
900 case OPEN_INPUT: {
901 CHECK_INTERFACE(IAudioFlinger, data, reply);
902 audio_module_handle_t module = (audio_module_handle_t)data.readInt32();
903 audio_devices_t devices = (audio_devices_t)data.readInt32();
904 uint32_t samplingRate = data.readInt32();
905 audio_format_t format = (audio_format_t) data.readInt32();
906 audio_channel_mask_t channelMask = (audio_channel_mask_t)data.readInt32();
907
908 audio_io_handle_t input = openInput(module,
909 &devices,
910 &samplingRate,
911 &format,
912 &channelMask);
913 reply->writeInt32((int32_t) input);
914 reply->writeInt32(devices);
915 reply->writeInt32(samplingRate);
916 reply->writeInt32(format);
917 reply->writeInt32(channelMask);
918 return NO_ERROR;
919 } break;
920 case CLOSE_INPUT: {
921 CHECK_INTERFACE(IAudioFlinger, data, reply);
922 reply->writeInt32(closeInput((audio_io_handle_t) data.readInt32()));
923 return NO_ERROR;
924 } break;
925 case SET_STREAM_OUTPUT: {
926 CHECK_INTERFACE(IAudioFlinger, data, reply);
927 uint32_t stream = data.readInt32();
928 audio_io_handle_t output = (audio_io_handle_t) data.readInt32();
929 reply->writeInt32(setStreamOutput((audio_stream_type_t) stream, output));
930 return NO_ERROR;
931 } break;
932 case SET_VOICE_VOLUME: {
933 CHECK_INTERFACE(IAudioFlinger, data, reply);
934 float volume = data.readFloat();
935 reply->writeInt32( setVoiceVolume(volume) );
936 return NO_ERROR;
937 } break;
938 case GET_RENDER_POSITION: {
939 CHECK_INTERFACE(IAudioFlinger, data, reply);
940 audio_io_handle_t output = (audio_io_handle_t) data.readInt32();
941 uint32_t halFrames;
942 uint32_t dspFrames;
943 status_t status = getRenderPosition(&halFrames, &dspFrames, output);
944 reply->writeInt32(status);
945 if (status == NO_ERROR) {
946 reply->writeInt32(halFrames);
947 reply->writeInt32(dspFrames);
948 }
949 return NO_ERROR;
950 }
951 case GET_INPUT_FRAMES_LOST: {
952 CHECK_INTERFACE(IAudioFlinger, data, reply);
953 audio_io_handle_t ioHandle = (audio_io_handle_t) data.readInt32();
954 reply->writeInt32(getInputFramesLost(ioHandle));
955 return NO_ERROR;
956 } break;
957 case NEW_AUDIO_SESSION_ID: {
958 CHECK_INTERFACE(IAudioFlinger, data, reply);
959 reply->writeInt32(newAudioSessionId());
960 return NO_ERROR;
961 } break;
962 case ACQUIRE_AUDIO_SESSION_ID: {
963 CHECK_INTERFACE(IAudioFlinger, data, reply);
964 int audioSession = data.readInt32();
965 acquireAudioSessionId(audioSession);
966 return NO_ERROR;
967 } break;
968 case RELEASE_AUDIO_SESSION_ID: {
969 CHECK_INTERFACE(IAudioFlinger, data, reply);
970 int audioSession = data.readInt32();
971 releaseAudioSessionId(audioSession);
972 return NO_ERROR;
973 } break;
974 case QUERY_NUM_EFFECTS: {
975 CHECK_INTERFACE(IAudioFlinger, data, reply);
976 uint32_t numEffects;
977 status_t status = queryNumberEffects(&numEffects);
978 reply->writeInt32(status);
979 if (status == NO_ERROR) {
980 reply->writeInt32((int32_t)numEffects);
981 }
982 return NO_ERROR;
983 }
984 case QUERY_EFFECT: {
985 CHECK_INTERFACE(IAudioFlinger, data, reply);
986 effect_descriptor_t desc;
987 status_t status = queryEffect(data.readInt32(), &desc);
988 reply->writeInt32(status);
989 if (status == NO_ERROR) {
990 reply->write(&desc, sizeof(effect_descriptor_t));
991 }
992 return NO_ERROR;
993 }
994 case GET_EFFECT_DESCRIPTOR: {
995 CHECK_INTERFACE(IAudioFlinger, data, reply);
996 effect_uuid_t uuid;
997 data.read(&uuid, sizeof(effect_uuid_t));
998 effect_descriptor_t desc;
999 status_t status = getEffectDescriptor(&uuid, &desc);
1000 reply->writeInt32(status);
1001 if (status == NO_ERROR) {
1002 reply->write(&desc, sizeof(effect_descriptor_t));
1003 }
1004 return NO_ERROR;
1005 }
1006 case CREATE_EFFECT: {
1007 CHECK_INTERFACE(IAudioFlinger, data, reply);
1008 pid_t pid = data.readInt32();
1009 effect_descriptor_t desc;
1010 data.read(&desc, sizeof(effect_descriptor_t));
1011 sp<IEffectClient> client = interface_cast<IEffectClient>(data.readStrongBinder());
1012 int32_t priority = data.readInt32();
1013 audio_io_handle_t output = (audio_io_handle_t) data.readInt32();
1014 int sessionId = data.readInt32();
1015 status_t status;
1016 int id;
1017 int enabled;
1018
1019 sp<IEffect> effect = createEffect(pid, &desc, client, priority, output, sessionId, &status, &id, &enabled);
1020 reply->writeInt32(status);
1021 reply->writeInt32(id);
1022 reply->writeInt32(enabled);
1023 reply->writeStrongBinder(effect->asBinder());
1024 reply->write(&desc, sizeof(effect_descriptor_t));
1025 return NO_ERROR;
1026 } break;
1027 case MOVE_EFFECTS: {
1028 CHECK_INTERFACE(IAudioFlinger, data, reply);
1029 int session = data.readInt32();
1030 audio_io_handle_t srcOutput = (audio_io_handle_t) data.readInt32();
1031 audio_io_handle_t dstOutput = (audio_io_handle_t) data.readInt32();
1032 reply->writeInt32(moveEffects(session, srcOutput, dstOutput));
1033 return NO_ERROR;
1034 } break;
1035 case LOAD_HW_MODULE: {
1036 CHECK_INTERFACE(IAudioFlinger, data, reply);
1037 reply->writeInt32(loadHwModule(data.readCString()));
1038 return NO_ERROR;
1039 } break;
1040 default:
1041 return BBinder::onTransact(code, data, reply, flags);
1042 }
1043 }
1044
1045 // ----------------------------------------------------------------------------
1046
1047 }; // namespace android
1048