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