1 /* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ANDROID_IAUDIOFLINGER_H 18 #define ANDROID_IAUDIOFLINGER_H 19 20 #include <stdint.h> 21 #include <sys/types.h> 22 #include <unistd.h> 23 24 #include <utils/RefBase.h> 25 #include <utils/Errors.h> 26 #include <binder/IInterface.h> 27 #include <binder/Parcel.h> 28 #include <binder/Parcelable.h> 29 #include <media/AudioClient.h> 30 #include <media/DeviceDescriptorBase.h> 31 #include <media/IAudioTrack.h> 32 #include <media/IAudioFlingerClient.h> 33 #include <system/audio.h> 34 #include <system/audio_effect.h> 35 #include <system/audio_policy.h> 36 #include <media/IEffect.h> 37 #include <media/IEffectClient.h> 38 #include <utils/String8.h> 39 #include <media/MicrophoneInfo.h> 40 #include <string> 41 #include <vector> 42 43 #include "android/media/IAudioRecord.h" 44 #include "android/media/IAudioTrackCallback.h" 45 46 namespace android { 47 48 // ---------------------------------------------------------------------------- 49 50 class IAudioFlinger : public IInterface 51 { 52 public: 53 DECLARE_META_INTERFACE(AudioFlinger); 54 55 /* CreateTrackInput contains all input arguments sent by AudioTrack to AudioFlinger 56 * when calling createTrack() including arguments that will be updated by AudioFlinger 57 * and returned in CreateTrackOutput object 58 */ 59 class CreateTrackInput : public Parcelable { 60 public: readFromParcel(const Parcel * parcel)61 status_t readFromParcel(const Parcel *parcel) override { 62 /* input arguments*/ 63 memset(&attr, 0, sizeof(audio_attributes_t)); 64 if (parcel->read(&attr, sizeof(audio_attributes_t)) != NO_ERROR) { 65 return DEAD_OBJECT; 66 } 67 attr.tags[AUDIO_ATTRIBUTES_TAGS_MAX_SIZE -1] = '\0'; 68 memset(&config, 0, sizeof(audio_config_t)); 69 if (parcel->read(&config, sizeof(audio_config_t)) != NO_ERROR) { 70 return DEAD_OBJECT; 71 } 72 if (clientInfo.readFromParcel(parcel) != NO_ERROR) { 73 return DEAD_OBJECT; 74 } 75 if (parcel->readInt32() != 0) { 76 // TODO: Using unsecurePointer() has some associated security 77 // pitfalls (see declaration for details). 78 // Either document why it is safe in this case or address 79 // the issue (e.g. by copying). 80 sharedBuffer = interface_cast<IMemory>(parcel->readStrongBinder()); 81 if (sharedBuffer == 0 || sharedBuffer->unsecurePointer() == NULL) { 82 return BAD_VALUE; 83 } 84 } 85 notificationsPerBuffer = parcel->readInt32(); 86 speed = parcel->readFloat(); 87 audioTrackCallback = interface_cast<media::IAudioTrackCallback>( 88 parcel->readStrongBinder()); 89 const char* opPackageNamePtr = parcel->readCString(); 90 if (opPackageNamePtr == nullptr) { 91 return FAILED_TRANSACTION; 92 } 93 opPackageName = opPackageNamePtr; 94 95 /* input/output arguments*/ 96 (void)parcel->read(&flags, sizeof(audio_output_flags_t)); 97 frameCount = parcel->readInt64(); 98 notificationFrameCount = parcel->readInt64(); 99 (void)parcel->read(&selectedDeviceId, sizeof(audio_port_handle_t)); 100 (void)parcel->read(&sessionId, sizeof(audio_session_t)); 101 return NO_ERROR; 102 } 103 writeToParcel(Parcel * parcel)104 status_t writeToParcel(Parcel *parcel) const override { 105 /* input arguments*/ 106 (void)parcel->write(&attr, sizeof(audio_attributes_t)); 107 (void)parcel->write(&config, sizeof(audio_config_t)); 108 (void)clientInfo.writeToParcel(parcel); 109 if (sharedBuffer != 0) { 110 (void)parcel->writeInt32(1); 111 (void)parcel->writeStrongBinder(IInterface::asBinder(sharedBuffer)); 112 } else { 113 (void)parcel->writeInt32(0); 114 } 115 (void)parcel->writeInt32(notificationsPerBuffer); 116 (void)parcel->writeFloat(speed); 117 (void)parcel->writeStrongBinder(IInterface::asBinder(audioTrackCallback)); 118 (void)parcel->writeCString(opPackageName.c_str()); 119 120 /* input/output arguments*/ 121 (void)parcel->write(&flags, sizeof(audio_output_flags_t)); 122 (void)parcel->writeInt64(frameCount); 123 (void)parcel->writeInt64(notificationFrameCount); 124 (void)parcel->write(&selectedDeviceId, sizeof(audio_port_handle_t)); 125 (void)parcel->write(&sessionId, sizeof(audio_session_t)); 126 return NO_ERROR; 127 } 128 129 /* input */ 130 audio_attributes_t attr; 131 audio_config_t config; 132 AudioClient clientInfo; 133 sp<IMemory> sharedBuffer; 134 uint32_t notificationsPerBuffer; 135 float speed; 136 sp<media::IAudioTrackCallback> audioTrackCallback; 137 std::string opPackageName; 138 139 /* input/output */ 140 audio_output_flags_t flags; 141 size_t frameCount; 142 size_t notificationFrameCount; 143 audio_port_handle_t selectedDeviceId; 144 audio_session_t sessionId; 145 }; 146 147 /* CreateTrackOutput contains all output arguments returned by AudioFlinger to AudioTrack 148 * when calling createTrack() including arguments that were passed as I/O for update by 149 * CreateTrackInput. 150 */ 151 class CreateTrackOutput : public Parcelable { 152 public: readFromParcel(const Parcel * parcel)153 status_t readFromParcel(const Parcel *parcel) override { 154 /* input/output arguments*/ 155 (void)parcel->read(&flags, sizeof(audio_output_flags_t)); 156 frameCount = parcel->readInt64(); 157 notificationFrameCount = parcel->readInt64(); 158 (void)parcel->read(&selectedDeviceId, sizeof(audio_port_handle_t)); 159 (void)parcel->read(&sessionId, sizeof(audio_session_t)); 160 161 /* output arguments*/ 162 sampleRate = parcel->readUint32(); 163 afFrameCount = parcel->readInt64(); 164 afSampleRate = parcel->readInt64(); 165 afLatencyMs = parcel->readInt32(); 166 (void)parcel->read(&outputId, sizeof(audio_io_handle_t)); 167 (void)parcel->read(&portId, sizeof(audio_port_handle_t)); 168 return NO_ERROR; 169 } 170 writeToParcel(Parcel * parcel)171 status_t writeToParcel(Parcel *parcel) const override { 172 /* input/output arguments*/ 173 (void)parcel->write(&flags, sizeof(audio_output_flags_t)); 174 (void)parcel->writeInt64(frameCount); 175 (void)parcel->writeInt64(notificationFrameCount); 176 (void)parcel->write(&selectedDeviceId, sizeof(audio_port_handle_t)); 177 (void)parcel->write(&sessionId, sizeof(audio_session_t)); 178 179 /* output arguments*/ 180 (void)parcel->writeUint32(sampleRate); 181 (void)parcel->writeInt64(afFrameCount); 182 (void)parcel->writeInt64(afSampleRate); 183 (void)parcel->writeInt32(afLatencyMs); 184 (void)parcel->write(&outputId, sizeof(audio_io_handle_t)); 185 (void)parcel->write(&portId, sizeof(audio_port_handle_t)); 186 return NO_ERROR; 187 } 188 189 /* input/output */ 190 audio_output_flags_t flags; 191 size_t frameCount; 192 size_t notificationFrameCount; 193 audio_port_handle_t selectedDeviceId; 194 audio_session_t sessionId; 195 196 /* output */ 197 uint32_t sampleRate; 198 size_t afFrameCount; 199 uint32_t afSampleRate; 200 uint32_t afLatencyMs; 201 audio_io_handle_t outputId; 202 audio_port_handle_t portId; 203 }; 204 205 /* CreateRecordInput contains all input arguments sent by AudioRecord to AudioFlinger 206 * when calling createRecord() including arguments that will be updated by AudioFlinger 207 * and returned in CreateRecordOutput object 208 */ 209 class CreateRecordInput : public Parcelable { 210 public: readFromParcel(const Parcel * parcel)211 status_t readFromParcel(const Parcel *parcel) override { 212 /* input arguments*/ 213 memset(&attr, 0, sizeof(audio_attributes_t)); 214 if (parcel->read(&attr, sizeof(audio_attributes_t)) != NO_ERROR) { 215 return DEAD_OBJECT; 216 } 217 attr.tags[AUDIO_ATTRIBUTES_TAGS_MAX_SIZE -1] = '\0'; 218 memset(&config, 0, sizeof(audio_config_base_t)); 219 if (parcel->read(&config, sizeof(audio_config_base_t)) != NO_ERROR) { 220 return DEAD_OBJECT; 221 } 222 if (clientInfo.readFromParcel(parcel) != NO_ERROR) { 223 return DEAD_OBJECT; 224 } 225 opPackageName = parcel->readString16(); 226 if (parcel->read(&riid, sizeof(audio_unique_id_t)) != NO_ERROR) { 227 return DEAD_OBJECT; 228 } 229 230 /* input/output arguments*/ 231 (void)parcel->read(&flags, sizeof(audio_input_flags_t)); 232 frameCount = parcel->readInt64(); 233 notificationFrameCount = parcel->readInt64(); 234 (void)parcel->read(&selectedDeviceId, sizeof(audio_port_handle_t)); 235 (void)parcel->read(&sessionId, sizeof(audio_session_t)); 236 return NO_ERROR; 237 } 238 writeToParcel(Parcel * parcel)239 status_t writeToParcel(Parcel *parcel) const override { 240 /* input arguments*/ 241 (void)parcel->write(&attr, sizeof(audio_attributes_t)); 242 (void)parcel->write(&config, sizeof(audio_config_base_t)); 243 (void)clientInfo.writeToParcel(parcel); 244 (void)parcel->writeString16(opPackageName); 245 (void)parcel->write(&riid, sizeof(audio_unique_id_t)); 246 247 /* input/output arguments*/ 248 (void)parcel->write(&flags, sizeof(audio_input_flags_t)); 249 (void)parcel->writeInt64(frameCount); 250 (void)parcel->writeInt64(notificationFrameCount); 251 (void)parcel->write(&selectedDeviceId, sizeof(audio_port_handle_t)); 252 (void)parcel->write(&sessionId, sizeof(audio_session_t)); 253 return NO_ERROR; 254 } 255 256 /* input */ 257 audio_attributes_t attr; 258 audio_config_base_t config; 259 AudioClient clientInfo; 260 String16 opPackageName; 261 audio_unique_id_t riid; 262 263 /* input/output */ 264 audio_input_flags_t flags; 265 size_t frameCount; 266 size_t notificationFrameCount; 267 audio_port_handle_t selectedDeviceId; 268 audio_session_t sessionId; 269 }; 270 271 /* CreateRecordOutput contains all output arguments returned by AudioFlinger to AudioRecord 272 * when calling createRecord() including arguments that were passed as I/O for update by 273 * CreateRecordInput. 274 */ 275 class CreateRecordOutput : public Parcelable { 276 public: readFromParcel(const Parcel * parcel)277 status_t readFromParcel(const Parcel *parcel) override { 278 /* input/output arguments*/ 279 (void)parcel->read(&flags, sizeof(audio_input_flags_t)); 280 frameCount = parcel->readInt64(); 281 notificationFrameCount = parcel->readInt64(); 282 (void)parcel->read(&selectedDeviceId, sizeof(audio_port_handle_t)); 283 (void)parcel->read(&sessionId, sizeof(audio_session_t)); 284 285 /* output arguments*/ 286 sampleRate = parcel->readUint32(); 287 (void)parcel->read(&inputId, sizeof(audio_io_handle_t)); 288 if (parcel->readInt32() != 0) { 289 cblk = interface_cast<IMemory>(parcel->readStrongBinder()); 290 // TODO: Using unsecurePointer() has some associated security 291 // pitfalls (see declaration for details). 292 // Either document why it is safe in this case or address 293 // the issue (e.g. by copying). 294 if (cblk == 0 || cblk->unsecurePointer() == NULL) { 295 return BAD_VALUE; 296 } 297 } 298 if (parcel->readInt32() != 0) { 299 buffers = interface_cast<IMemory>(parcel->readStrongBinder()); 300 // TODO: Using unsecurePointer() has some associated security 301 // pitfalls (see declaration for details). 302 // Either document why it is safe in this case or address 303 // the issue (e.g. by copying). 304 if (buffers == 0 || buffers->unsecurePointer() == NULL) { 305 return BAD_VALUE; 306 } 307 } 308 (void)parcel->read(&portId, sizeof(audio_port_handle_t)); 309 return NO_ERROR; 310 } 311 writeToParcel(Parcel * parcel)312 status_t writeToParcel(Parcel *parcel) const override { 313 /* input/output arguments*/ 314 (void)parcel->write(&flags, sizeof(audio_input_flags_t)); 315 (void)parcel->writeInt64(frameCount); 316 (void)parcel->writeInt64(notificationFrameCount); 317 (void)parcel->write(&selectedDeviceId, sizeof(audio_port_handle_t)); 318 (void)parcel->write(&sessionId, sizeof(audio_session_t)); 319 320 /* output arguments*/ 321 (void)parcel->writeUint32(sampleRate); 322 (void)parcel->write(&inputId, sizeof(audio_io_handle_t)); 323 if (cblk != 0) { 324 (void)parcel->writeInt32(1); 325 (void)parcel->writeStrongBinder(IInterface::asBinder(cblk)); 326 } else { 327 (void)parcel->writeInt32(0); 328 } 329 if (buffers != 0) { 330 (void)parcel->writeInt32(1); 331 (void)parcel->writeStrongBinder(IInterface::asBinder(buffers)); 332 } else { 333 (void)parcel->writeInt32(0); 334 } 335 (void)parcel->write(&portId, sizeof(audio_port_handle_t)); 336 337 return NO_ERROR; 338 } 339 340 /* input/output */ 341 audio_input_flags_t flags; 342 size_t frameCount; 343 size_t notificationFrameCount; 344 audio_port_handle_t selectedDeviceId; 345 audio_session_t sessionId; 346 347 /* output */ 348 uint32_t sampleRate; 349 audio_io_handle_t inputId; 350 sp<IMemory> cblk; 351 sp<IMemory> buffers; 352 audio_port_handle_t portId; 353 }; 354 355 // invariant on exit for all APIs that return an sp<>: 356 // (return value != 0) == (*status == NO_ERROR) 357 358 /* create an audio track and registers it with AudioFlinger. 359 * return null if the track cannot be created. 360 */ 361 virtual sp<IAudioTrack> createTrack(const CreateTrackInput& input, 362 CreateTrackOutput& output, 363 status_t *status) = 0; 364 365 virtual sp<media::IAudioRecord> createRecord(const CreateRecordInput& input, 366 CreateRecordOutput& output, 367 status_t *status) = 0; 368 369 // FIXME Surprisingly, format/latency don't work for input handles 370 371 /* query the audio hardware state. This state never changes, 372 * and therefore can be cached. 373 */ 374 virtual uint32_t sampleRate(audio_io_handle_t ioHandle) const = 0; 375 376 // reserved; formerly channelCount() 377 378 virtual audio_format_t format(audio_io_handle_t output) const = 0; 379 virtual size_t frameCount(audio_io_handle_t ioHandle) const = 0; 380 381 // return estimated latency in milliseconds 382 virtual uint32_t latency(audio_io_handle_t output) const = 0; 383 384 /* set/get the audio hardware state. This will probably be used by 385 * the preference panel, mostly. 386 */ 387 virtual status_t setMasterVolume(float value) = 0; 388 virtual status_t setMasterMute(bool muted) = 0; 389 390 virtual float masterVolume() const = 0; 391 virtual bool masterMute() const = 0; 392 393 virtual status_t setMasterBalance(float balance) = 0; 394 virtual status_t getMasterBalance(float *balance) const = 0; 395 396 /* set/get stream type state. This will probably be used by 397 * the preference panel, mostly. 398 */ 399 virtual status_t setStreamVolume(audio_stream_type_t stream, float value, 400 audio_io_handle_t output) = 0; 401 virtual status_t setStreamMute(audio_stream_type_t stream, bool muted) = 0; 402 403 virtual float streamVolume(audio_stream_type_t stream, 404 audio_io_handle_t output) const = 0; 405 virtual bool streamMute(audio_stream_type_t stream) const = 0; 406 407 // set audio mode 408 virtual status_t setMode(audio_mode_t mode) = 0; 409 410 // mic mute/state 411 virtual status_t setMicMute(bool state) = 0; 412 virtual bool getMicMute() const = 0; 413 virtual void setRecordSilenced(audio_port_handle_t portId, bool silenced) = 0; 414 415 virtual status_t setParameters(audio_io_handle_t ioHandle, 416 const String8& keyValuePairs) = 0; 417 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) 418 const = 0; 419 420 // Register an object to receive audio input/output change and track notifications. 421 // For a given calling pid, AudioFlinger disregards any registrations after the first. 422 // Thus the IAudioFlingerClient must be a singleton per process. 423 virtual void registerClient(const sp<IAudioFlingerClient>& client) = 0; 424 425 // retrieve the audio recording buffer size in bytes 426 // FIXME This API assumes a route, and so should be deprecated. 427 virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, 428 audio_channel_mask_t channelMask) const = 0; 429 430 virtual status_t openOutput(audio_module_handle_t module, 431 audio_io_handle_t *output, 432 audio_config_t *config, 433 const sp<DeviceDescriptorBase>& device, 434 uint32_t *latencyMs, 435 audio_output_flags_t flags) = 0; 436 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, 437 audio_io_handle_t output2) = 0; 438 virtual status_t closeOutput(audio_io_handle_t output) = 0; 439 virtual status_t suspendOutput(audio_io_handle_t output) = 0; 440 virtual status_t restoreOutput(audio_io_handle_t output) = 0; 441 442 virtual status_t openInput(audio_module_handle_t module, 443 audio_io_handle_t *input, 444 audio_config_t *config, 445 audio_devices_t *device, 446 const String8& address, 447 audio_source_t source, 448 audio_input_flags_t flags) = 0; 449 virtual status_t closeInput(audio_io_handle_t input) = 0; 450 451 virtual status_t invalidateStream(audio_stream_type_t stream) = 0; 452 453 virtual status_t setVoiceVolume(float volume) = 0; 454 455 virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames, 456 audio_io_handle_t output) const = 0; 457 458 virtual uint32_t getInputFramesLost(audio_io_handle_t ioHandle) const = 0; 459 460 virtual audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use) = 0; 461 462 virtual void acquireAudioSessionId(audio_session_t audioSession, pid_t pid, uid_t uid) = 0; 463 virtual void releaseAudioSessionId(audio_session_t audioSession, pid_t pid) = 0; 464 465 virtual status_t queryNumberEffects(uint32_t *numEffects) const = 0; 466 467 virtual status_t queryEffect(uint32_t index, effect_descriptor_t *pDescriptor) const = 0; 468 469 virtual status_t getEffectDescriptor(const effect_uuid_t *pEffectUUID, 470 const effect_uuid_t *pTypeUUID, 471 uint32_t preferredTypeFlag, 472 effect_descriptor_t *pDescriptor) const = 0; 473 474 virtual sp<IEffect> createEffect( 475 effect_descriptor_t *pDesc, 476 const sp<IEffectClient>& client, 477 int32_t priority, 478 // AudioFlinger doesn't take over handle reference from client 479 audio_io_handle_t output, 480 audio_session_t sessionId, 481 const AudioDeviceTypeAddr& device, 482 const String16& callingPackage, 483 pid_t pid, 484 bool probe, 485 status_t *status, 486 int *id, 487 int *enabled) = 0; 488 489 virtual status_t moveEffects(audio_session_t session, audio_io_handle_t srcOutput, 490 audio_io_handle_t dstOutput) = 0; 491 492 virtual void setEffectSuspended(int effectId, 493 audio_session_t sessionId, 494 bool suspended) = 0; 495 496 virtual audio_module_handle_t loadHwModule(const char *name) = 0; 497 498 // helpers for android.media.AudioManager.getProperty(), see description there for meaning 499 // FIXME move these APIs to AudioPolicy to permit a more accurate implementation 500 // that looks on primary device for a stream with fast flag, primary flag, or first one. 501 virtual uint32_t getPrimaryOutputSamplingRate() = 0; 502 virtual size_t getPrimaryOutputFrameCount() = 0; 503 504 // Intended for AudioService to inform AudioFlinger of device's low RAM attribute, 505 // and should be called at most once. For a definition of what "low RAM" means, see 506 // android.app.ActivityManager.isLowRamDevice(). The totalMemory parameter 507 // is obtained from android.app.ActivityManager.MemoryInfo.totalMem. 508 virtual status_t setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) = 0; 509 510 /* List available audio ports and their attributes */ 511 virtual status_t listAudioPorts(unsigned int *num_ports, 512 struct audio_port *ports) = 0; 513 514 /* Get attributes for a given audio port */ 515 virtual status_t getAudioPort(struct audio_port *port) = 0; 516 517 /* Create an audio patch between several source and sink ports */ 518 virtual status_t createAudioPatch(const struct audio_patch *patch, 519 audio_patch_handle_t *handle) = 0; 520 521 /* Release an audio patch */ 522 virtual status_t releaseAudioPatch(audio_patch_handle_t handle) = 0; 523 524 /* List existing audio patches */ 525 virtual status_t listAudioPatches(unsigned int *num_patches, 526 struct audio_patch *patches) = 0; 527 /* Set audio port configuration */ 528 virtual status_t setAudioPortConfig(const struct audio_port_config *config) = 0; 529 530 /* Get the HW synchronization source used for an audio session */ 531 virtual audio_hw_sync_t getAudioHwSyncForSession(audio_session_t sessionId) = 0; 532 533 /* Indicate JAVA services are ready (scheduling, power management ...) */ 534 virtual status_t systemReady() = 0; 535 536 // Returns the number of frames per audio HAL buffer. 537 virtual size_t frameCountHAL(audio_io_handle_t ioHandle) const = 0; 538 539 /* List available microphones and their characteristics */ 540 virtual status_t getMicrophones(std::vector<media::MicrophoneInfo> *microphones) = 0; 541 542 virtual status_t setAudioHalPids(const std::vector<pid_t>& pids) = 0; 543 }; 544 545 546 // ---------------------------------------------------------------------------- 547 548 class BnAudioFlinger : public BnInterface<IAudioFlinger> 549 { 550 public: 551 virtual status_t onTransact( uint32_t code, 552 const Parcel& data, 553 Parcel* reply, 554 uint32_t flags = 0); 555 556 // Requests media.log to start merging log buffers 557 virtual void requestLogMerge() = 0; 558 }; 559 560 // ---------------------------------------------------------------------------- 561 562 }; // namespace android 563 564 #endif // ANDROID_IAUDIOFLINGER_H 565