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