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