IAudioFlinger.cpp revision 5841db78dff14898538200287d246577b1fc37e2 
1/* //device/extlibs/pv/android/IAudioflinger.cpp
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
29namespace android {
30
31enum {
32    CREATE_TRACK = IBinder::FIRST_CALL_TRANSACTION,
33    OPEN_RECORD,
34    SAMPLE_RATE,
35    CHANNEL_COUNT,
36    FORMAT,
37    FRAME_COUNT,
38    LATENCY,
39    SET_MASTER_VOLUME,
40    SET_MASTER_MUTE,
41    MASTER_VOLUME,
42    MASTER_MUTE,
43    SET_STREAM_VOLUME,
44    SET_STREAM_MUTE,
45    STREAM_VOLUME,
46    STREAM_MUTE,
47    SET_MODE,
48    SET_MIC_MUTE,
49    GET_MIC_MUTE,
50    IS_MUSIC_ACTIVE,
51    SET_PARAMETERS,
52    GET_PARAMETERS,
53    REGISTER_CLIENT,
54    GET_INPUTBUFFERSIZE,
55    OPEN_OUTPUT,
56    OPEN_DUPLICATE_OUTPUT,
57    CLOSE_OUTPUT,
58    SUSPEND_OUTPUT,
59    RESTORE_OUTPUT,
60    OPEN_INPUT,
61    CLOSE_INPUT,
62    SET_STREAM_OUTPUT
63};
64
65class BpAudioFlinger : public BpInterface<IAudioFlinger>
66{
67public:
68    BpAudioFlinger(const sp<IBinder>& impl)
69        : BpInterface<IAudioFlinger>(impl)
70    {
71    }
72
73    virtual sp<IAudioTrack> createTrack(
74                                pid_t pid,
75                                int streamType,
76                                uint32_t sampleRate,
77                                int format,
78                                int channelCount,
79                                int frameCount,
80                                uint32_t flags,
81                                const sp<IMemory>& sharedBuffer,
82                                int output,
83                                status_t *status)
84    {
85        Parcel data, reply;
86        sp<IAudioTrack> track;
87        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
88        data.writeInt32(pid);
89        data.writeInt32(streamType);
90        data.writeInt32(sampleRate);
91        data.writeInt32(format);
92        data.writeInt32(channelCount);
93        data.writeInt32(frameCount);
94        data.writeInt32(flags);
95        data.writeStrongBinder(sharedBuffer->asBinder());
96        data.writeInt32(output);
97        status_t lStatus = remote()->transact(CREATE_TRACK, data, &reply);
98        if (lStatus != NO_ERROR) {
99            LOGE("createTrack error: %s", strerror(-lStatus));
100        } else {
101            lStatus = reply.readInt32();
102            track = interface_cast<IAudioTrack>(reply.readStrongBinder());
103        }
104        if (status) {
105            *status = lStatus;
106        }
107        return track;
108    }
109
110    virtual sp<IAudioRecord> openRecord(
111                                pid_t pid,
112                                int input,
113                                uint32_t sampleRate,
114                                int format,
115                                int channelCount,
116                                int frameCount,
117                                uint32_t flags,
118                                status_t *status)
119    {
120        Parcel data, reply;
121        sp<IAudioRecord> record;
122        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
123        data.writeInt32(pid);
124        data.writeInt32(input);
125        data.writeInt32(sampleRate);
126        data.writeInt32(format);
127        data.writeInt32(channelCount);
128        data.writeInt32(frameCount);
129        data.writeInt32(flags);
130        status_t lStatus = remote()->transact(OPEN_RECORD, data, &reply);
131        if (lStatus != NO_ERROR) {
132            LOGE("openRecord error: %s", strerror(-lStatus));
133        } else {
134            lStatus = reply.readInt32();
135            record = interface_cast<IAudioRecord>(reply.readStrongBinder());
136        }
137        if (status) {
138            *status = lStatus;
139        }
140        return record;
141    }
142
143    virtual uint32_t sampleRate(int output) const
144    {
145        Parcel data, reply;
146        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
147        data.writeInt32(output);
148        remote()->transact(SAMPLE_RATE, data, &reply);
149        return reply.readInt32();
150    }
151
152    virtual int channelCount(int output) const
153    {
154        Parcel data, reply;
155        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
156        data.writeInt32(output);
157        remote()->transact(CHANNEL_COUNT, data, &reply);
158        return reply.readInt32();
159    }
160
161    virtual int format(int output) const
162    {
163        Parcel data, reply;
164        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
165        data.writeInt32(output);
166        remote()->transact(FORMAT, data, &reply);
167        return reply.readInt32();
168    }
169
170    virtual size_t frameCount(int output) const
171    {
172        Parcel data, reply;
173        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
174        data.writeInt32(output);
175        remote()->transact(FRAME_COUNT, data, &reply);
176        return reply.readInt32();
177    }
178
179    virtual uint32_t latency(int output) const
180    {
181        Parcel data, reply;
182        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
183        data.writeInt32(output);
184        remote()->transact(LATENCY, data, &reply);
185        return reply.readInt32();
186    }
187
188    virtual status_t setMasterVolume(float value)
189    {
190        Parcel data, reply;
191        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
192        data.writeFloat(value);
193        remote()->transact(SET_MASTER_VOLUME, data, &reply);
194        return reply.readInt32();
195    }
196
197    virtual status_t setMasterMute(bool muted)
198    {
199        Parcel data, reply;
200        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
201        data.writeInt32(muted);
202        remote()->transact(SET_MASTER_MUTE, data, &reply);
203        return reply.readInt32();
204    }
205
206    virtual float masterVolume() const
207    {
208        Parcel data, reply;
209        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
210        remote()->transact(MASTER_VOLUME, data, &reply);
211        return reply.readFloat();
212    }
213
214    virtual bool masterMute() const
215    {
216        Parcel data, reply;
217        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
218        remote()->transact(MASTER_MUTE, data, &reply);
219        return reply.readInt32();
220    }
221
222    virtual status_t setStreamVolume(int stream, float value, int output)
223    {
224        Parcel data, reply;
225        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
226        data.writeInt32(stream);
227        data.writeFloat(value);
228        data.writeInt32(output);
229        remote()->transact(SET_STREAM_VOLUME, data, &reply);
230        return reply.readInt32();
231    }
232
233    virtual status_t setStreamMute(int stream, bool muted)
234    {
235        Parcel data, reply;
236        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
237        data.writeInt32(stream);
238        data.writeInt32(muted);
239        remote()->transact(SET_STREAM_MUTE, data, &reply);
240        return reply.readInt32();
241    }
242
243    virtual float streamVolume(int stream, int output) const
244    {
245        Parcel data, reply;
246        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
247        data.writeInt32(stream);
248        data.writeInt32(output);
249        remote()->transact(STREAM_VOLUME, data, &reply);
250        return reply.readFloat();
251    }
252
253    virtual bool streamMute(int stream) const
254    {
255        Parcel data, reply;
256        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
257        data.writeInt32(stream);
258        remote()->transact(STREAM_MUTE, data, &reply);
259        return reply.readInt32();
260    }
261
262    virtual status_t setMode(int mode)
263    {
264        Parcel data, reply;
265        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
266        data.writeInt32(mode);
267        remote()->transact(SET_MODE, data, &reply);
268        return reply.readInt32();
269    }
270
271    virtual status_t setMicMute(bool state)
272    {
273        Parcel data, reply;
274        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
275        data.writeInt32(state);
276        remote()->transact(SET_MIC_MUTE, data, &reply);
277        return reply.readInt32();
278    }
279
280    virtual bool getMicMute() const
281    {
282        Parcel data, reply;
283        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
284        remote()->transact(GET_MIC_MUTE, data, &reply);
285        return reply.readInt32();
286    }
287
288    virtual bool isMusicActive() const
289    {
290        Parcel data, reply;
291        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
292        remote()->transact(IS_MUSIC_ACTIVE, data, &reply);
293        return reply.readInt32();
294    }
295
296    virtual status_t setParameters(int ioHandle, const String8& keyValuePairs)
297    {
298        Parcel data, reply;
299        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
300        data.writeInt32(ioHandle);
301        data.writeString8(keyValuePairs);
302        remote()->transact(SET_PARAMETERS, data, &reply);
303        return reply.readInt32();
304    }
305
306    virtual String8 getParameters(int ioHandle, const String8& keys)
307    {
308        Parcel data, reply;
309        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
310        data.writeInt32(ioHandle);
311        data.writeString8(keys);
312        remote()->transact(GET_PARAMETERS, data, &reply);
313        return reply.readString8();
314    }
315
316    virtual void registerClient(const sp<IAudioFlingerClient>& client)
317    {
318        Parcel data, reply;
319        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
320        data.writeStrongBinder(client->asBinder());
321        remote()->transact(REGISTER_CLIENT, data, &reply);
322    }
323
324    virtual size_t getInputBufferSize(uint32_t sampleRate, int format, int channelCount)
325    {
326        Parcel data, reply;
327        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
328        data.writeInt32(sampleRate);
329        data.writeInt32(format);
330        data.writeInt32(channelCount);
331        remote()->transact(GET_INPUTBUFFERSIZE, data, &reply);
332        return reply.readInt32();
333    }
334
335    virtual int openOutput(uint32_t *pDevices,
336                            uint32_t *pSamplingRate,
337                            uint32_t *pFormat,
338                            uint32_t *pChannels,
339                            uint32_t *pLatencyMs,
340                            uint32_t flags)
341    {
342        Parcel data, reply;
343        uint32_t devices = pDevices ? *pDevices : 0;
344        uint32_t samplingRate = pSamplingRate ? *pSamplingRate : 0;
345        uint32_t format = pFormat ? *pFormat : 0;
346        uint32_t channels = pChannels ? *pChannels : 0;
347        uint32_t latency = pLatencyMs ? *pLatencyMs : 0;
348
349        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
350        data.writeInt32(devices);
351        data.writeInt32(samplingRate);
352        data.writeInt32(format);
353        data.writeInt32(channels);
354        data.writeInt32(latency);
355        data.writeInt32(flags);
356        remote()->transact(OPEN_OUTPUT, data, &reply);
357        int  output = reply.readInt32();
358        LOGV("openOutput() returned output, %p", output);
359        devices = reply.readInt32();
360        if (pDevices) *pDevices = devices;
361        samplingRate = reply.readInt32();
362        if (pSamplingRate) *pSamplingRate = samplingRate;
363        format = reply.readInt32();
364        if (pFormat) *pFormat = format;
365        channels = reply.readInt32();
366        if (pChannels) *pChannels = channels;
367        latency = reply.readInt32();
368        if (pLatencyMs) *pLatencyMs = latency;
369        return output;
370    }
371
372    virtual int openDuplicateOutput(int output1, int output2)
373    {
374        Parcel data, reply;
375        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
376        data.writeInt32(output1);
377        data.writeInt32(output2);
378        remote()->transact(OPEN_DUPLICATE_OUTPUT, data, &reply);
379        return reply.readInt32();
380    }
381
382    virtual status_t closeOutput(int output)
383    {
384        Parcel data, reply;
385        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
386        data.writeInt32(output);
387        remote()->transact(CLOSE_OUTPUT, data, &reply);
388        return reply.readInt32();
389    }
390
391    virtual status_t suspendOutput(int output)
392    {
393        Parcel data, reply;
394        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
395        data.writeInt32(output);
396        remote()->transact(SUSPEND_OUTPUT, data, &reply);
397        return reply.readInt32();
398    }
399
400    virtual status_t restoreOutput(int output)
401    {
402        Parcel data, reply;
403        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
404        data.writeInt32(output);
405        remote()->transact(RESTORE_OUTPUT, data, &reply);
406        return reply.readInt32();
407    }
408
409    virtual int openInput(uint32_t *pDevices,
410                            uint32_t *pSamplingRate,
411                            uint32_t *pFormat,
412                            uint32_t *pChannels,
413                            uint32_t acoustics)
414    {
415        Parcel data, reply;
416        uint32_t devices = pDevices ? *pDevices : 0;
417        uint32_t samplingRate = pSamplingRate ? *pSamplingRate : 0;
418        uint32_t format = pFormat ? *pFormat : 0;
419        uint32_t channels = pChannels ? *pChannels : 0;
420
421        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
422        data.writeInt32(devices);
423        data.writeInt32(samplingRate);
424        data.writeInt32(format);
425        data.writeInt32(channels);
426        data.writeInt32(acoustics);
427        remote()->transact(OPEN_INPUT, data, &reply);
428        int input = reply.readInt32();
429        devices = reply.readInt32();
430        if (pDevices) *pDevices = devices;
431        samplingRate = reply.readInt32();
432        if (pSamplingRate) *pSamplingRate = samplingRate;
433        format = reply.readInt32();
434        if (pFormat) *pFormat = format;
435        channels = reply.readInt32();
436        if (pChannels) *pChannels = channels;
437        return input;
438    }
439
440    virtual status_t closeInput(int input)
441    {
442        Parcel data, reply;
443        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
444        data.writeInt32(input);
445        remote()->transact(CLOSE_INPUT, data, &reply);
446        return reply.readInt32();
447    }
448
449    virtual status_t setStreamOutput(uint32_t stream, int output)
450    {
451        Parcel data, reply;
452        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
453        data.writeInt32(stream);
454        data.writeInt32(output);
455        remote()->transact(SET_STREAM_OUTPUT, data, &reply);
456        return reply.readInt32();
457    }
458};
459
460IMPLEMENT_META_INTERFACE(AudioFlinger, "android.media.IAudioFlinger");
461
462// ----------------------------------------------------------------------
463
464status_t BnAudioFlinger::onTransact(
465    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
466{
467    switch(code) {
468        case CREATE_TRACK: {
469            CHECK_INTERFACE(IAudioFlinger, data, reply);
470            pid_t pid = data.readInt32();
471            int streamType = data.readInt32();
472            uint32_t sampleRate = data.readInt32();
473            int format = data.readInt32();
474            int channelCount = data.readInt32();
475            size_t bufferCount = data.readInt32();
476            uint32_t flags = data.readInt32();
477            sp<IMemory> buffer = interface_cast<IMemory>(data.readStrongBinder());
478            int output = data.readInt32();
479            status_t status;
480            sp<IAudioTrack> track = createTrack(pid,
481                    streamType, sampleRate, format,
482                    channelCount, bufferCount, flags, buffer, output, &status);
483            reply->writeInt32(status);
484            reply->writeStrongBinder(track->asBinder());
485            return NO_ERROR;
486        } break;
487        case OPEN_RECORD: {
488            CHECK_INTERFACE(IAudioFlinger, data, reply);
489            pid_t pid = data.readInt32();
490            int input = data.readInt32();
491            uint32_t sampleRate = data.readInt32();
492            int format = data.readInt32();
493            int channelCount = data.readInt32();
494            size_t bufferCount = data.readInt32();
495            uint32_t flags = data.readInt32();
496            status_t status;
497            sp<IAudioRecord> record = openRecord(pid, input,
498                    sampleRate, format, channelCount, bufferCount, flags, &status);
499            reply->writeInt32(status);
500            reply->writeStrongBinder(record->asBinder());
501            return NO_ERROR;
502        } break;
503        case SAMPLE_RATE: {
504            CHECK_INTERFACE(IAudioFlinger, data, reply);
505            reply->writeInt32( sampleRate(data.readInt32()) );
506            return NO_ERROR;
507        } break;
508        case CHANNEL_COUNT: {
509            CHECK_INTERFACE(IAudioFlinger, data, reply);
510            reply->writeInt32( channelCount(data.readInt32()) );
511            return NO_ERROR;
512        } break;
513        case FORMAT: {
514            CHECK_INTERFACE(IAudioFlinger, data, reply);
515            reply->writeInt32( format(data.readInt32()) );
516            return NO_ERROR;
517        } break;
518        case FRAME_COUNT: {
519            CHECK_INTERFACE(IAudioFlinger, data, reply);
520            reply->writeInt32( frameCount(data.readInt32()) );
521            return NO_ERROR;
522        } break;
523        case LATENCY: {
524            CHECK_INTERFACE(IAudioFlinger, data, reply);
525            reply->writeInt32( latency(data.readInt32()) );
526            return NO_ERROR;
527        } break;
528         case SET_MASTER_VOLUME: {
529            CHECK_INTERFACE(IAudioFlinger, data, reply);
530            reply->writeInt32( setMasterVolume(data.readFloat()) );
531            return NO_ERROR;
532        } break;
533        case SET_MASTER_MUTE: {
534            CHECK_INTERFACE(IAudioFlinger, data, reply);
535            reply->writeInt32( setMasterMute(data.readInt32()) );
536            return NO_ERROR;
537        } break;
538        case MASTER_VOLUME: {
539            CHECK_INTERFACE(IAudioFlinger, data, reply);
540            reply->writeFloat( masterVolume() );
541            return NO_ERROR;
542        } break;
543        case MASTER_MUTE: {
544            CHECK_INTERFACE(IAudioFlinger, data, reply);
545            reply->writeInt32( masterMute() );
546            return NO_ERROR;
547        } break;
548        case SET_STREAM_VOLUME: {
549            CHECK_INTERFACE(IAudioFlinger, data, reply);
550            int stream = data.readInt32();
551            float volume = data.readFloat();
552            int output = data.readInt32();
553            reply->writeInt32( setStreamVolume(stream, volume, output) );
554            return NO_ERROR;
555        } break;
556        case SET_STREAM_MUTE: {
557            CHECK_INTERFACE(IAudioFlinger, data, reply);
558            int stream = data.readInt32();
559            reply->writeInt32( setStreamMute(stream, data.readInt32()) );
560            return NO_ERROR;
561        } break;
562        case STREAM_VOLUME: {
563            CHECK_INTERFACE(IAudioFlinger, data, reply);
564            int stream = data.readInt32();
565            int output = data.readInt32();
566            reply->writeFloat( streamVolume(stream, output) );
567            return NO_ERROR;
568        } break;
569        case STREAM_MUTE: {
570            CHECK_INTERFACE(IAudioFlinger, data, reply);
571            int stream = data.readInt32();
572            reply->writeInt32( streamMute(stream) );
573            return NO_ERROR;
574        } break;
575        case SET_MODE: {
576            CHECK_INTERFACE(IAudioFlinger, data, reply);
577            int mode = data.readInt32();
578            reply->writeInt32( setMode(mode) );
579            return NO_ERROR;
580        } break;
581        case SET_MIC_MUTE: {
582            CHECK_INTERFACE(IAudioFlinger, data, reply);
583            int state = data.readInt32();
584            reply->writeInt32( setMicMute(state) );
585            return NO_ERROR;
586        } break;
587        case GET_MIC_MUTE: {
588            CHECK_INTERFACE(IAudioFlinger, data, reply);
589            reply->writeInt32( getMicMute() );
590            return NO_ERROR;
591        } break;
592        case IS_MUSIC_ACTIVE: {
593            CHECK_INTERFACE(IAudioFlinger, data, reply);
594            reply->writeInt32( isMusicActive() );
595            return NO_ERROR;
596        } break;
597        case SET_PARAMETERS: {
598            CHECK_INTERFACE(IAudioFlinger, data, reply);
599            int ioHandle = data.readInt32();
600            String8 keyValuePairs(data.readString8());
601            reply->writeInt32(setParameters(ioHandle, keyValuePairs));
602            return NO_ERROR;
603         } break;
604        case GET_PARAMETERS: {
605            CHECK_INTERFACE(IAudioFlinger, data, reply);
606            int ioHandle = data.readInt32();
607            String8 keys(data.readString8());
608            reply->writeString8(getParameters(ioHandle, keys));
609            return NO_ERROR;
610         } break;
611
612        case REGISTER_CLIENT: {
613            CHECK_INTERFACE(IAudioFlinger, data, reply);
614            sp<IAudioFlingerClient> client = interface_cast<IAudioFlingerClient>(data.readStrongBinder());
615            registerClient(client);
616            return NO_ERROR;
617        } break;
618        case GET_INPUTBUFFERSIZE: {
619            CHECK_INTERFACE(IAudioFlinger, data, reply);
620            uint32_t sampleRate = data.readInt32();
621            int format = data.readInt32();
622            int channelCount = data.readInt32();
623            reply->writeInt32( getInputBufferSize(sampleRate, format, channelCount) );
624            return NO_ERROR;
625        } break;
626        case OPEN_OUTPUT: {
627            CHECK_INTERFACE(IAudioFlinger, data, reply);
628            uint32_t devices = data.readInt32();
629            uint32_t samplingRate = data.readInt32();
630            uint32_t format = data.readInt32();
631            uint32_t channels = data.readInt32();
632            uint32_t latency = data.readInt32();
633            uint32_t flags = data.readInt32();
634            int output = openOutput(&devices,
635                                     &samplingRate,
636                                     &format,
637                                     &channels,
638                                     &latency,
639                                     flags);
640            LOGV("OPEN_OUTPUT output, %p", output);
641            reply->writeInt32(output);
642            reply->writeInt32(devices);
643            reply->writeInt32(samplingRate);
644            reply->writeInt32(format);
645            reply->writeInt32(channels);
646            reply->writeInt32(latency);
647            return NO_ERROR;
648        } break;
649        case OPEN_DUPLICATE_OUTPUT: {
650            CHECK_INTERFACE(IAudioFlinger, data, reply);
651            int output1 = data.readInt32();
652            int output2 = data.readInt32();
653            reply->writeInt32(openDuplicateOutput(output1, output2));
654            return NO_ERROR;
655        } break;
656        case CLOSE_OUTPUT: {
657            CHECK_INTERFACE(IAudioFlinger, data, reply);
658            reply->writeInt32(closeOutput(data.readInt32()));
659            return NO_ERROR;
660        } break;
661        case SUSPEND_OUTPUT: {
662            CHECK_INTERFACE(IAudioFlinger, data, reply);
663            reply->writeInt32(suspendOutput(data.readInt32()));
664            return NO_ERROR;
665        } break;
666        case RESTORE_OUTPUT: {
667            CHECK_INTERFACE(IAudioFlinger, data, reply);
668            reply->writeInt32(restoreOutput(data.readInt32()));
669            return NO_ERROR;
670        } break;
671        case OPEN_INPUT: {
672            CHECK_INTERFACE(IAudioFlinger, data, reply);
673            uint32_t devices = data.readInt32();
674            uint32_t samplingRate = data.readInt32();
675            uint32_t format = data.readInt32();
676            uint32_t channels = data.readInt32();
677            uint32_t acoutics = data.readInt32();
678
679            int input = openInput(&devices,
680                                     &samplingRate,
681                                     &format,
682                                     &channels,
683                                     acoutics);
684            reply->writeInt32(input);
685            reply->writeInt32(devices);
686            reply->writeInt32(samplingRate);
687            reply->writeInt32(format);
688            reply->writeInt32(channels);
689            return NO_ERROR;
690        } break;
691        case CLOSE_INPUT: {
692            CHECK_INTERFACE(IAudioFlinger, data, reply);
693            reply->writeInt32(closeInput(data.readInt32()));
694            return NO_ERROR;
695        } break;
696        case SET_STREAM_OUTPUT: {
697            CHECK_INTERFACE(IAudioFlinger, data, reply);
698            uint32_t stream = data.readInt32();
699            int output = data.readInt32();
700            reply->writeInt32(setStreamOutput(stream, output));
701            return NO_ERROR;
702        } break;
703        default:
704            return BBinder::onTransact(code, data, reply, flags);
705    }
706}
707
708// ----------------------------------------------------------------------------
709
710}; // namespace android
711