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