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