1 /* 2 ** 3 ** Copyright 2007, The Android Open Source Project 4 ** 5 ** Licensed under the Apache License, Version 2.0 (the "License"); 6 ** you may not use this file except in compliance with the License. 7 ** You may obtain a copy of the License at 8 ** 9 ** http://www.apache.org/licenses/LICENSE-2.0 10 ** 11 ** Unless required by applicable law or agreed to in writing, software 12 ** distributed under the License is distributed on an "AS IS" BASIS, 13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 ** See the License for the specific language governing permissions and 15 ** limitations under the License. 16 */ 17 18 #define LOG_TAG "IAudioFlinger" 19 //#define LOG_NDEBUG 0 20 #include <utils/Log.h> 21 22 #include <stdint.h> 23 #include <sys/types.h> 24 25 #include <binder/Parcel.h> 26 27 #include <media/IAudioFlinger.h> 28 29 namespace android { 30 31 enum { 32 CREATE_TRACK = IBinder::FIRST_CALL_TRANSACTION, 33 OPEN_RECORD, 34 SAMPLE_RATE, 35 RESERVED, // obsolete, was 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 SET_PARAMETERS, 51 GET_PARAMETERS, 52 REGISTER_CLIENT, 53 GET_INPUTBUFFERSIZE, 54 OPEN_OUTPUT, 55 OPEN_DUPLICATE_OUTPUT, 56 CLOSE_OUTPUT, 57 SUSPEND_OUTPUT, 58 RESTORE_OUTPUT, 59 OPEN_INPUT, 60 CLOSE_INPUT, 61 SET_STREAM_OUTPUT, 62 SET_VOICE_VOLUME, 63 GET_RENDER_POSITION, 64 GET_INPUT_FRAMES_LOST, 65 NEW_AUDIO_SESSION_ID, 66 ACQUIRE_AUDIO_SESSION_ID, 67 RELEASE_AUDIO_SESSION_ID, 68 QUERY_NUM_EFFECTS, 69 QUERY_EFFECT, 70 GET_EFFECT_DESCRIPTOR, 71 CREATE_EFFECT, 72 MOVE_EFFECTS, 73 LOAD_HW_MODULE, 74 GET_PRIMARY_OUTPUT_SAMPLING_RATE, 75 GET_PRIMARY_OUTPUT_FRAME_COUNT, 76 SET_LOW_RAM_DEVICE, 77 }; 78 79 class BpAudioFlinger : public BpInterface<IAudioFlinger> 80 { 81 public: 82 BpAudioFlinger(const sp<IBinder>& impl) 83 : BpInterface<IAudioFlinger>(impl) 84 { 85 } 86 87 virtual sp<IAudioTrack> createTrack( 88 audio_stream_type_t streamType, 89 uint32_t sampleRate, 90 audio_format_t format, 91 audio_channel_mask_t channelMask, 92 size_t frameCount, 93 track_flags_t *flags, 94 const sp<IMemory>& sharedBuffer, 95 audio_io_handle_t output, 96 pid_t tid, 97 int *sessionId, 98 String8& name, 99 status_t *status) 100 { 101 Parcel data, reply; 102 sp<IAudioTrack> track; 103 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 104 data.writeInt32((int32_t) streamType); 105 data.writeInt32(sampleRate); 106 data.writeInt32(format); 107 data.writeInt32(channelMask); 108 data.writeInt32(frameCount); 109 track_flags_t lFlags = flags != NULL ? *flags : (track_flags_t) TRACK_DEFAULT; 110 data.writeInt32(lFlags); 111 if (sharedBuffer != 0) { 112 data.writeInt32(true); 113 data.writeStrongBinder(sharedBuffer->asBinder()); 114 } else { 115 data.writeInt32(false); 116 } 117 data.writeInt32((int32_t) output); 118 data.writeInt32((int32_t) tid); 119 int lSessionId = 0; 120 if (sessionId != NULL) { 121 lSessionId = *sessionId; 122 } 123 data.writeInt32(lSessionId); 124 status_t lStatus = remote()->transact(CREATE_TRACK, data, &reply); 125 if (lStatus != NO_ERROR) { 126 ALOGE("createTrack error: %s", strerror(-lStatus)); 127 } else { 128 lFlags = reply.readInt32(); 129 if (flags != NULL) { 130 *flags = lFlags; 131 } 132 lSessionId = reply.readInt32(); 133 if (sessionId != NULL) { 134 *sessionId = lSessionId; 135 } 136 name = reply.readString8(); 137 lStatus = reply.readInt32(); 138 track = interface_cast<IAudioTrack>(reply.readStrongBinder()); 139 } 140 if (status) { 141 *status = lStatus; 142 } 143 return track; 144 } 145 146 virtual sp<IAudioRecord> openRecord( 147 audio_io_handle_t input, 148 uint32_t sampleRate, 149 audio_format_t format, 150 audio_channel_mask_t channelMask, 151 size_t frameCount, 152 track_flags_t *flags, 153 pid_t tid, 154 int *sessionId, 155 status_t *status) 156 { 157 Parcel data, reply; 158 sp<IAudioRecord> record; 159 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 160 data.writeInt32((int32_t) input); 161 data.writeInt32(sampleRate); 162 data.writeInt32(format); 163 data.writeInt32(channelMask); 164 data.writeInt32(frameCount); 165 track_flags_t lFlags = flags != NULL ? *flags : (track_flags_t) TRACK_DEFAULT; 166 data.writeInt32(lFlags); 167 data.writeInt32((int32_t) tid); 168 int lSessionId = 0; 169 if (sessionId != NULL) { 170 lSessionId = *sessionId; 171 } 172 data.writeInt32(lSessionId); 173 status_t lStatus = remote()->transact(OPEN_RECORD, data, &reply); 174 if (lStatus != NO_ERROR) { 175 ALOGE("openRecord error: %s", strerror(-lStatus)); 176 } else { 177 lFlags = reply.readInt32(); 178 if (flags != NULL) { 179 *flags = lFlags; 180 } 181 lSessionId = reply.readInt32(); 182 if (sessionId != NULL) { 183 *sessionId = lSessionId; 184 } 185 lStatus = reply.readInt32(); 186 record = interface_cast<IAudioRecord>(reply.readStrongBinder()); 187 if (lStatus == NO_ERROR) { 188 if (record == 0) { 189 ALOGE("openRecord should have returned an IAudioRecord"); 190 lStatus = UNKNOWN_ERROR; 191 } 192 } else { 193 if (record != 0) { 194 ALOGE("openRecord returned an IAudioRecord but with status %d", lStatus); 195 record.clear(); 196 } 197 } 198 } 199 if (status) { 200 *status = lStatus; 201 } 202 return record; 203 } 204 205 virtual uint32_t sampleRate(audio_io_handle_t output) const 206 { 207 Parcel data, reply; 208 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 209 data.writeInt32((int32_t) output); 210 remote()->transact(SAMPLE_RATE, data, &reply); 211 return reply.readInt32(); 212 } 213 214 virtual audio_format_t format(audio_io_handle_t output) const 215 { 216 Parcel data, reply; 217 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 218 data.writeInt32((int32_t) output); 219 remote()->transact(FORMAT, data, &reply); 220 return (audio_format_t) reply.readInt32(); 221 } 222 223 virtual size_t frameCount(audio_io_handle_t output) const 224 { 225 Parcel data, reply; 226 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 227 data.writeInt32((int32_t) output); 228 remote()->transact(FRAME_COUNT, data, &reply); 229 return reply.readInt32(); 230 } 231 232 virtual uint32_t latency(audio_io_handle_t output) const 233 { 234 Parcel data, reply; 235 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 236 data.writeInt32((int32_t) output); 237 remote()->transact(LATENCY, data, &reply); 238 return reply.readInt32(); 239 } 240 241 virtual status_t setMasterVolume(float value) 242 { 243 Parcel data, reply; 244 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 245 data.writeFloat(value); 246 remote()->transact(SET_MASTER_VOLUME, data, &reply); 247 return reply.readInt32(); 248 } 249 250 virtual status_t setMasterMute(bool muted) 251 { 252 Parcel data, reply; 253 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 254 data.writeInt32(muted); 255 remote()->transact(SET_MASTER_MUTE, data, &reply); 256 return reply.readInt32(); 257 } 258 259 virtual float masterVolume() const 260 { 261 Parcel data, reply; 262 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 263 remote()->transact(MASTER_VOLUME, data, &reply); 264 return reply.readFloat(); 265 } 266 267 virtual bool masterMute() const 268 { 269 Parcel data, reply; 270 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 271 remote()->transact(MASTER_MUTE, data, &reply); 272 return reply.readInt32(); 273 } 274 275 virtual status_t setStreamVolume(audio_stream_type_t stream, float value, 276 audio_io_handle_t output) 277 { 278 Parcel data, reply; 279 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 280 data.writeInt32((int32_t) stream); 281 data.writeFloat(value); 282 data.writeInt32((int32_t) output); 283 remote()->transact(SET_STREAM_VOLUME, data, &reply); 284 return reply.readInt32(); 285 } 286 287 virtual status_t setStreamMute(audio_stream_type_t stream, bool muted) 288 { 289 Parcel data, reply; 290 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 291 data.writeInt32((int32_t) stream); 292 data.writeInt32(muted); 293 remote()->transact(SET_STREAM_MUTE, data, &reply); 294 return reply.readInt32(); 295 } 296 297 virtual float streamVolume(audio_stream_type_t stream, audio_io_handle_t output) const 298 { 299 Parcel data, reply; 300 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 301 data.writeInt32((int32_t) stream); 302 data.writeInt32((int32_t) output); 303 remote()->transact(STREAM_VOLUME, data, &reply); 304 return reply.readFloat(); 305 } 306 307 virtual bool streamMute(audio_stream_type_t stream) const 308 { 309 Parcel data, reply; 310 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 311 data.writeInt32((int32_t) stream); 312 remote()->transact(STREAM_MUTE, data, &reply); 313 return reply.readInt32(); 314 } 315 316 virtual status_t setMode(audio_mode_t mode) 317 { 318 Parcel data, reply; 319 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 320 data.writeInt32(mode); 321 remote()->transact(SET_MODE, data, &reply); 322 return reply.readInt32(); 323 } 324 325 virtual status_t setMicMute(bool state) 326 { 327 Parcel data, reply; 328 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 329 data.writeInt32(state); 330 remote()->transact(SET_MIC_MUTE, data, &reply); 331 return reply.readInt32(); 332 } 333 334 virtual bool getMicMute() const 335 { 336 Parcel data, reply; 337 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 338 remote()->transact(GET_MIC_MUTE, data, &reply); 339 return reply.readInt32(); 340 } 341 342 virtual status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs) 343 { 344 Parcel data, reply; 345 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 346 data.writeInt32((int32_t) ioHandle); 347 data.writeString8(keyValuePairs); 348 remote()->transact(SET_PARAMETERS, data, &reply); 349 return reply.readInt32(); 350 } 351 352 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) const 353 { 354 Parcel data, reply; 355 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 356 data.writeInt32((int32_t) ioHandle); 357 data.writeString8(keys); 358 remote()->transact(GET_PARAMETERS, data, &reply); 359 return reply.readString8(); 360 } 361 362 virtual void registerClient(const sp<IAudioFlingerClient>& client) 363 { 364 Parcel data, reply; 365 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 366 data.writeStrongBinder(client->asBinder()); 367 remote()->transact(REGISTER_CLIENT, data, &reply); 368 } 369 370 virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, 371 audio_channel_mask_t channelMask) const 372 { 373 Parcel data, reply; 374 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 375 data.writeInt32(sampleRate); 376 data.writeInt32(format); 377 data.writeInt32(channelMask); 378 remote()->transact(GET_INPUTBUFFERSIZE, data, &reply); 379 return reply.readInt32(); 380 } 381 382 virtual audio_io_handle_t openOutput(audio_module_handle_t module, 383 audio_devices_t *pDevices, 384 uint32_t *pSamplingRate, 385 audio_format_t *pFormat, 386 audio_channel_mask_t *pChannelMask, 387 uint32_t *pLatencyMs, 388 audio_output_flags_t flags, 389 const audio_offload_info_t *offloadInfo) 390 { 391 Parcel data, reply; 392 audio_devices_t devices = pDevices != NULL ? *pDevices : (audio_devices_t)0; 393 uint32_t samplingRate = pSamplingRate != NULL ? *pSamplingRate : 0; 394 audio_format_t format = pFormat != NULL ? *pFormat : AUDIO_FORMAT_DEFAULT; 395 audio_channel_mask_t channelMask = pChannelMask != NULL ? 396 *pChannelMask : (audio_channel_mask_t)0; 397 uint32_t latency = pLatencyMs != NULL ? *pLatencyMs : 0; 398 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 399 data.writeInt32(module); 400 data.writeInt32(devices); 401 data.writeInt32(samplingRate); 402 data.writeInt32(format); 403 data.writeInt32(channelMask); 404 data.writeInt32(latency); 405 data.writeInt32((int32_t) flags); 406 if (offloadInfo == NULL) { 407 data.writeInt32(0); 408 } else { 409 data.writeInt32(1); 410 data.write(offloadInfo, sizeof(audio_offload_info_t)); 411 } 412 remote()->transact(OPEN_OUTPUT, data, &reply); 413 audio_io_handle_t output = (audio_io_handle_t) reply.readInt32(); 414 ALOGV("openOutput() returned output, %d", output); 415 devices = (audio_devices_t)reply.readInt32(); 416 if (pDevices != NULL) *pDevices = devices; 417 samplingRate = reply.readInt32(); 418 if (pSamplingRate != NULL) *pSamplingRate = samplingRate; 419 format = (audio_format_t) reply.readInt32(); 420 if (pFormat != NULL) *pFormat = format; 421 channelMask = (audio_channel_mask_t)reply.readInt32(); 422 if (pChannelMask != NULL) *pChannelMask = channelMask; 423 latency = reply.readInt32(); 424 if (pLatencyMs != NULL) *pLatencyMs = latency; 425 return output; 426 } 427 428 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, 429 audio_io_handle_t output2) 430 { 431 Parcel data, reply; 432 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 433 data.writeInt32((int32_t) output1); 434 data.writeInt32((int32_t) output2); 435 remote()->transact(OPEN_DUPLICATE_OUTPUT, data, &reply); 436 return (audio_io_handle_t) reply.readInt32(); 437 } 438 439 virtual status_t closeOutput(audio_io_handle_t output) 440 { 441 Parcel data, reply; 442 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 443 data.writeInt32((int32_t) output); 444 remote()->transact(CLOSE_OUTPUT, data, &reply); 445 return reply.readInt32(); 446 } 447 448 virtual status_t suspendOutput(audio_io_handle_t output) 449 { 450 Parcel data, reply; 451 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 452 data.writeInt32((int32_t) output); 453 remote()->transact(SUSPEND_OUTPUT, data, &reply); 454 return reply.readInt32(); 455 } 456 457 virtual status_t restoreOutput(audio_io_handle_t output) 458 { 459 Parcel data, reply; 460 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 461 data.writeInt32((int32_t) output); 462 remote()->transact(RESTORE_OUTPUT, data, &reply); 463 return reply.readInt32(); 464 } 465 466 virtual audio_io_handle_t openInput(audio_module_handle_t module, 467 audio_devices_t *pDevices, 468 uint32_t *pSamplingRate, 469 audio_format_t *pFormat, 470 audio_channel_mask_t *pChannelMask) 471 { 472 Parcel data, reply; 473 audio_devices_t devices = pDevices != NULL ? *pDevices : (audio_devices_t)0; 474 uint32_t samplingRate = pSamplingRate != NULL ? *pSamplingRate : 0; 475 audio_format_t format = pFormat != NULL ? *pFormat : AUDIO_FORMAT_DEFAULT; 476 audio_channel_mask_t channelMask = pChannelMask != NULL ? 477 *pChannelMask : (audio_channel_mask_t)0; 478 479 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 480 data.writeInt32(module); 481 data.writeInt32(devices); 482 data.writeInt32(samplingRate); 483 data.writeInt32(format); 484 data.writeInt32(channelMask); 485 remote()->transact(OPEN_INPUT, data, &reply); 486 audio_io_handle_t input = (audio_io_handle_t) reply.readInt32(); 487 devices = (audio_devices_t)reply.readInt32(); 488 if (pDevices != NULL) *pDevices = devices; 489 samplingRate = reply.readInt32(); 490 if (pSamplingRate != NULL) *pSamplingRate = samplingRate; 491 format = (audio_format_t) reply.readInt32(); 492 if (pFormat != NULL) *pFormat = format; 493 channelMask = (audio_channel_mask_t)reply.readInt32(); 494 if (pChannelMask != NULL) *pChannelMask = channelMask; 495 return input; 496 } 497 498 virtual status_t closeInput(int input) 499 { 500 Parcel data, reply; 501 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 502 data.writeInt32(input); 503 remote()->transact(CLOSE_INPUT, data, &reply); 504 return reply.readInt32(); 505 } 506 507 virtual status_t setStreamOutput(audio_stream_type_t stream, audio_io_handle_t output) 508 { 509 Parcel data, reply; 510 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 511 data.writeInt32((int32_t) stream); 512 data.writeInt32((int32_t) output); 513 remote()->transact(SET_STREAM_OUTPUT, data, &reply); 514 return reply.readInt32(); 515 } 516 517 virtual status_t setVoiceVolume(float volume) 518 { 519 Parcel data, reply; 520 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 521 data.writeFloat(volume); 522 remote()->transact(SET_VOICE_VOLUME, data, &reply); 523 return reply.readInt32(); 524 } 525 526 virtual status_t getRenderPosition(size_t *halFrames, size_t *dspFrames, 527 audio_io_handle_t output) const 528 { 529 Parcel data, reply; 530 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 531 data.writeInt32((int32_t) output); 532 remote()->transact(GET_RENDER_POSITION, data, &reply); 533 status_t status = reply.readInt32(); 534 if (status == NO_ERROR) { 535 uint32_t tmp = reply.readInt32(); 536 if (halFrames) { 537 *halFrames = tmp; 538 } 539 tmp = reply.readInt32(); 540 if (dspFrames) { 541 *dspFrames = tmp; 542 } 543 } 544 return status; 545 } 546 547 virtual size_t getInputFramesLost(audio_io_handle_t ioHandle) const 548 { 549 Parcel data, reply; 550 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 551 data.writeInt32((int32_t) ioHandle); 552 remote()->transact(GET_INPUT_FRAMES_LOST, data, &reply); 553 return reply.readInt32(); 554 } 555 556 virtual int newAudioSessionId() 557 { 558 Parcel data, reply; 559 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 560 status_t status = remote()->transact(NEW_AUDIO_SESSION_ID, data, &reply); 561 int id = 0; 562 if (status == NO_ERROR) { 563 id = reply.readInt32(); 564 } 565 return id; 566 } 567 568 virtual void acquireAudioSessionId(int audioSession) 569 { 570 Parcel data, reply; 571 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 572 data.writeInt32(audioSession); 573 remote()->transact(ACQUIRE_AUDIO_SESSION_ID, data, &reply); 574 } 575 576 virtual void releaseAudioSessionId(int audioSession) 577 { 578 Parcel data, reply; 579 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 580 data.writeInt32(audioSession); 581 remote()->transact(RELEASE_AUDIO_SESSION_ID, data, &reply); 582 } 583 584 virtual status_t queryNumberEffects(uint32_t *numEffects) const 585 { 586 Parcel data, reply; 587 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 588 status_t status = remote()->transact(QUERY_NUM_EFFECTS, data, &reply); 589 if (status != NO_ERROR) { 590 return status; 591 } 592 status = reply.readInt32(); 593 if (status != NO_ERROR) { 594 return status; 595 } 596 if (numEffects != NULL) { 597 *numEffects = (uint32_t)reply.readInt32(); 598 } 599 return NO_ERROR; 600 } 601 602 virtual status_t queryEffect(uint32_t index, effect_descriptor_t *pDescriptor) const 603 { 604 if (pDescriptor == NULL) { 605 return BAD_VALUE; 606 } 607 Parcel data, reply; 608 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 609 data.writeInt32(index); 610 status_t status = remote()->transact(QUERY_EFFECT, data, &reply); 611 if (status != NO_ERROR) { 612 return status; 613 } 614 status = reply.readInt32(); 615 if (status != NO_ERROR) { 616 return status; 617 } 618 reply.read(pDescriptor, sizeof(effect_descriptor_t)); 619 return NO_ERROR; 620 } 621 622 virtual status_t getEffectDescriptor(const effect_uuid_t *pUuid, 623 effect_descriptor_t *pDescriptor) const 624 { 625 if (pUuid == NULL || pDescriptor == NULL) { 626 return BAD_VALUE; 627 } 628 Parcel data, reply; 629 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 630 data.write(pUuid, sizeof(effect_uuid_t)); 631 status_t status = remote()->transact(GET_EFFECT_DESCRIPTOR, data, &reply); 632 if (status != NO_ERROR) { 633 return status; 634 } 635 status = reply.readInt32(); 636 if (status != NO_ERROR) { 637 return status; 638 } 639 reply.read(pDescriptor, sizeof(effect_descriptor_t)); 640 return NO_ERROR; 641 } 642 643 virtual sp<IEffect> createEffect( 644 effect_descriptor_t *pDesc, 645 const sp<IEffectClient>& client, 646 int32_t priority, 647 audio_io_handle_t output, 648 int sessionId, 649 status_t *status, 650 int *id, 651 int *enabled) 652 { 653 Parcel data, reply; 654 sp<IEffect> effect; 655 656 if (pDesc == NULL) { 657 return effect; 658 if (status) { 659 *status = BAD_VALUE; 660 } 661 } 662 663 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 664 data.write(pDesc, sizeof(effect_descriptor_t)); 665 data.writeStrongBinder(client->asBinder()); 666 data.writeInt32(priority); 667 data.writeInt32((int32_t) output); 668 data.writeInt32(sessionId); 669 670 status_t lStatus = remote()->transact(CREATE_EFFECT, data, &reply); 671 if (lStatus != NO_ERROR) { 672 ALOGE("createEffect error: %s", strerror(-lStatus)); 673 } else { 674 lStatus = reply.readInt32(); 675 int tmp = reply.readInt32(); 676 if (id) { 677 *id = tmp; 678 } 679 tmp = reply.readInt32(); 680 if (enabled != NULL) { 681 *enabled = tmp; 682 } 683 effect = interface_cast<IEffect>(reply.readStrongBinder()); 684 reply.read(pDesc, sizeof(effect_descriptor_t)); 685 } 686 if (status) { 687 *status = lStatus; 688 } 689 690 return effect; 691 } 692 693 virtual status_t moveEffects(int session, audio_io_handle_t srcOutput, 694 audio_io_handle_t dstOutput) 695 { 696 Parcel data, reply; 697 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 698 data.writeInt32(session); 699 data.writeInt32((int32_t) srcOutput); 700 data.writeInt32((int32_t) dstOutput); 701 remote()->transact(MOVE_EFFECTS, data, &reply); 702 return reply.readInt32(); 703 } 704 705 virtual audio_module_handle_t loadHwModule(const char *name) 706 { 707 Parcel data, reply; 708 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 709 data.writeCString(name); 710 remote()->transact(LOAD_HW_MODULE, data, &reply); 711 return (audio_module_handle_t) reply.readInt32(); 712 } 713 714 virtual uint32_t getPrimaryOutputSamplingRate() 715 { 716 Parcel data, reply; 717 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 718 remote()->transact(GET_PRIMARY_OUTPUT_SAMPLING_RATE, data, &reply); 719 return reply.readInt32(); 720 } 721 722 virtual size_t getPrimaryOutputFrameCount() 723 { 724 Parcel data, reply; 725 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 726 remote()->transact(GET_PRIMARY_OUTPUT_FRAME_COUNT, data, &reply); 727 return reply.readInt32(); 728 } 729 730 virtual status_t setLowRamDevice(bool isLowRamDevice) 731 { 732 Parcel data, reply; 733 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 734 data.writeInt32((int) isLowRamDevice); 735 remote()->transact(SET_LOW_RAM_DEVICE, data, &reply); 736 return reply.readInt32(); 737 } 738 739 }; 740 741 IMPLEMENT_META_INTERFACE(AudioFlinger, "android.media.IAudioFlinger"); 742 743 // ---------------------------------------------------------------------- 744 745 status_t BnAudioFlinger::onTransact( 746 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 747 { 748 switch (code) { 749 case CREATE_TRACK: { 750 CHECK_INTERFACE(IAudioFlinger, data, reply); 751 int streamType = data.readInt32(); 752 uint32_t sampleRate = data.readInt32(); 753 audio_format_t format = (audio_format_t) data.readInt32(); 754 audio_channel_mask_t channelMask = data.readInt32(); 755 size_t frameCount = data.readInt32(); 756 track_flags_t flags = (track_flags_t) data.readInt32(); 757 bool haveSharedBuffer = data.readInt32() != 0; 758 sp<IMemory> buffer; 759 if (haveSharedBuffer) { 760 buffer = interface_cast<IMemory>(data.readStrongBinder()); 761 } 762 audio_io_handle_t output = (audio_io_handle_t) data.readInt32(); 763 pid_t tid = (pid_t) data.readInt32(); 764 int sessionId = data.readInt32(); 765 String8 name; 766 status_t status; 767 sp<IAudioTrack> track; 768 if ((haveSharedBuffer && (buffer == 0)) || 769 ((buffer != 0) && (buffer->pointer() == NULL))) { 770 ALOGW("CREATE_TRACK: cannot retrieve shared memory"); 771 status = DEAD_OBJECT; 772 } else { 773 track = createTrack( 774 (audio_stream_type_t) streamType, sampleRate, format, 775 channelMask, frameCount, &flags, buffer, output, tid, 776 &sessionId, name, &status); 777 } 778 reply->writeInt32(flags); 779 reply->writeInt32(sessionId); 780 reply->writeString8(name); 781 reply->writeInt32(status); 782 reply->writeStrongBinder(track->asBinder()); 783 return NO_ERROR; 784 } break; 785 case OPEN_RECORD: { 786 CHECK_INTERFACE(IAudioFlinger, data, reply); 787 audio_io_handle_t input = (audio_io_handle_t) data.readInt32(); 788 uint32_t sampleRate = data.readInt32(); 789 audio_format_t format = (audio_format_t) data.readInt32(); 790 audio_channel_mask_t channelMask = data.readInt32(); 791 size_t frameCount = data.readInt32(); 792 track_flags_t flags = (track_flags_t) data.readInt32(); 793 pid_t tid = (pid_t) data.readInt32(); 794 int sessionId = data.readInt32(); 795 status_t status; 796 sp<IAudioRecord> record = openRecord(input, 797 sampleRate, format, channelMask, frameCount, &flags, tid, &sessionId, &status); 798 LOG_ALWAYS_FATAL_IF((record != 0) != (status == NO_ERROR)); 799 reply->writeInt32(flags); 800 reply->writeInt32(sessionId); 801 reply->writeInt32(status); 802 reply->writeStrongBinder(record->asBinder()); 803 return NO_ERROR; 804 } break; 805 case SAMPLE_RATE: { 806 CHECK_INTERFACE(IAudioFlinger, data, reply); 807 reply->writeInt32( sampleRate((audio_io_handle_t) data.readInt32()) ); 808 return NO_ERROR; 809 } break; 810 case FORMAT: { 811 CHECK_INTERFACE(IAudioFlinger, data, reply); 812 reply->writeInt32( format((audio_io_handle_t) data.readInt32()) ); 813 return NO_ERROR; 814 } break; 815 case FRAME_COUNT: { 816 CHECK_INTERFACE(IAudioFlinger, data, reply); 817 reply->writeInt32( frameCount((audio_io_handle_t) data.readInt32()) ); 818 return NO_ERROR; 819 } break; 820 case LATENCY: { 821 CHECK_INTERFACE(IAudioFlinger, data, reply); 822 reply->writeInt32( latency((audio_io_handle_t) data.readInt32()) ); 823 return NO_ERROR; 824 } break; 825 case SET_MASTER_VOLUME: { 826 CHECK_INTERFACE(IAudioFlinger, data, reply); 827 reply->writeInt32( setMasterVolume(data.readFloat()) ); 828 return NO_ERROR; 829 } break; 830 case SET_MASTER_MUTE: { 831 CHECK_INTERFACE(IAudioFlinger, data, reply); 832 reply->writeInt32( setMasterMute(data.readInt32()) ); 833 return NO_ERROR; 834 } break; 835 case MASTER_VOLUME: { 836 CHECK_INTERFACE(IAudioFlinger, data, reply); 837 reply->writeFloat( masterVolume() ); 838 return NO_ERROR; 839 } break; 840 case MASTER_MUTE: { 841 CHECK_INTERFACE(IAudioFlinger, data, reply); 842 reply->writeInt32( masterMute() ); 843 return NO_ERROR; 844 } break; 845 case SET_STREAM_VOLUME: { 846 CHECK_INTERFACE(IAudioFlinger, data, reply); 847 int stream = data.readInt32(); 848 float volume = data.readFloat(); 849 audio_io_handle_t output = (audio_io_handle_t) data.readInt32(); 850 reply->writeInt32( setStreamVolume((audio_stream_type_t) stream, volume, output) ); 851 return NO_ERROR; 852 } break; 853 case SET_STREAM_MUTE: { 854 CHECK_INTERFACE(IAudioFlinger, data, reply); 855 int stream = data.readInt32(); 856 reply->writeInt32( setStreamMute((audio_stream_type_t) stream, data.readInt32()) ); 857 return NO_ERROR; 858 } break; 859 case STREAM_VOLUME: { 860 CHECK_INTERFACE(IAudioFlinger, data, reply); 861 int stream = data.readInt32(); 862 int output = data.readInt32(); 863 reply->writeFloat( streamVolume((audio_stream_type_t) stream, output) ); 864 return NO_ERROR; 865 } break; 866 case STREAM_MUTE: { 867 CHECK_INTERFACE(IAudioFlinger, data, reply); 868 int stream = data.readInt32(); 869 reply->writeInt32( streamMute((audio_stream_type_t) stream) ); 870 return NO_ERROR; 871 } break; 872 case SET_MODE: { 873 CHECK_INTERFACE(IAudioFlinger, data, reply); 874 audio_mode_t mode = (audio_mode_t) data.readInt32(); 875 reply->writeInt32( setMode(mode) ); 876 return NO_ERROR; 877 } break; 878 case SET_MIC_MUTE: { 879 CHECK_INTERFACE(IAudioFlinger, data, reply); 880 int state = data.readInt32(); 881 reply->writeInt32( setMicMute(state) ); 882 return NO_ERROR; 883 } break; 884 case GET_MIC_MUTE: { 885 CHECK_INTERFACE(IAudioFlinger, data, reply); 886 reply->writeInt32( getMicMute() ); 887 return NO_ERROR; 888 } break; 889 case SET_PARAMETERS: { 890 CHECK_INTERFACE(IAudioFlinger, data, reply); 891 audio_io_handle_t ioHandle = (audio_io_handle_t) data.readInt32(); 892 String8 keyValuePairs(data.readString8()); 893 reply->writeInt32(setParameters(ioHandle, keyValuePairs)); 894 return NO_ERROR; 895 } break; 896 case GET_PARAMETERS: { 897 CHECK_INTERFACE(IAudioFlinger, data, reply); 898 audio_io_handle_t ioHandle = (audio_io_handle_t) data.readInt32(); 899 String8 keys(data.readString8()); 900 reply->writeString8(getParameters(ioHandle, keys)); 901 return NO_ERROR; 902 } break; 903 904 case REGISTER_CLIENT: { 905 CHECK_INTERFACE(IAudioFlinger, data, reply); 906 sp<IAudioFlingerClient> client = interface_cast<IAudioFlingerClient>( 907 data.readStrongBinder()); 908 registerClient(client); 909 return NO_ERROR; 910 } break; 911 case GET_INPUTBUFFERSIZE: { 912 CHECK_INTERFACE(IAudioFlinger, data, reply); 913 uint32_t sampleRate = data.readInt32(); 914 audio_format_t format = (audio_format_t) data.readInt32(); 915 audio_channel_mask_t channelMask = data.readInt32(); 916 reply->writeInt32( getInputBufferSize(sampleRate, format, channelMask) ); 917 return NO_ERROR; 918 } break; 919 case OPEN_OUTPUT: { 920 CHECK_INTERFACE(IAudioFlinger, data, reply); 921 audio_module_handle_t module = (audio_module_handle_t)data.readInt32(); 922 audio_devices_t devices = (audio_devices_t)data.readInt32(); 923 uint32_t samplingRate = data.readInt32(); 924 audio_format_t format = (audio_format_t) data.readInt32(); 925 audio_channel_mask_t channelMask = (audio_channel_mask_t)data.readInt32(); 926 uint32_t latency = data.readInt32(); 927 audio_output_flags_t flags = (audio_output_flags_t) data.readInt32(); 928 bool hasOffloadInfo = data.readInt32() != 0; 929 audio_offload_info_t offloadInfo; 930 if (hasOffloadInfo) { 931 data.read(&offloadInfo, sizeof(audio_offload_info_t)); 932 } 933 audio_io_handle_t output = openOutput(module, 934 &devices, 935 &samplingRate, 936 &format, 937 &channelMask, 938 &latency, 939 flags, 940 hasOffloadInfo ? &offloadInfo : NULL); 941 ALOGV("OPEN_OUTPUT output, %p", output); 942 reply->writeInt32((int32_t) output); 943 reply->writeInt32(devices); 944 reply->writeInt32(samplingRate); 945 reply->writeInt32(format); 946 reply->writeInt32(channelMask); 947 reply->writeInt32(latency); 948 return NO_ERROR; 949 } break; 950 case OPEN_DUPLICATE_OUTPUT: { 951 CHECK_INTERFACE(IAudioFlinger, data, reply); 952 audio_io_handle_t output1 = (audio_io_handle_t) data.readInt32(); 953 audio_io_handle_t output2 = (audio_io_handle_t) data.readInt32(); 954 reply->writeInt32((int32_t) openDuplicateOutput(output1, output2)); 955 return NO_ERROR; 956 } break; 957 case CLOSE_OUTPUT: { 958 CHECK_INTERFACE(IAudioFlinger, data, reply); 959 reply->writeInt32(closeOutput((audio_io_handle_t) data.readInt32())); 960 return NO_ERROR; 961 } break; 962 case SUSPEND_OUTPUT: { 963 CHECK_INTERFACE(IAudioFlinger, data, reply); 964 reply->writeInt32(suspendOutput((audio_io_handle_t) data.readInt32())); 965 return NO_ERROR; 966 } break; 967 case RESTORE_OUTPUT: { 968 CHECK_INTERFACE(IAudioFlinger, data, reply); 969 reply->writeInt32(restoreOutput((audio_io_handle_t) data.readInt32())); 970 return NO_ERROR; 971 } break; 972 case OPEN_INPUT: { 973 CHECK_INTERFACE(IAudioFlinger, data, reply); 974 audio_module_handle_t module = (audio_module_handle_t)data.readInt32(); 975 audio_devices_t devices = (audio_devices_t)data.readInt32(); 976 uint32_t samplingRate = data.readInt32(); 977 audio_format_t format = (audio_format_t) data.readInt32(); 978 audio_channel_mask_t channelMask = (audio_channel_mask_t)data.readInt32(); 979 980 audio_io_handle_t input = openInput(module, 981 &devices, 982 &samplingRate, 983 &format, 984 &channelMask); 985 reply->writeInt32((int32_t) input); 986 reply->writeInt32(devices); 987 reply->writeInt32(samplingRate); 988 reply->writeInt32(format); 989 reply->writeInt32(channelMask); 990 return NO_ERROR; 991 } break; 992 case CLOSE_INPUT: { 993 CHECK_INTERFACE(IAudioFlinger, data, reply); 994 reply->writeInt32(closeInput((audio_io_handle_t) data.readInt32())); 995 return NO_ERROR; 996 } break; 997 case SET_STREAM_OUTPUT: { 998 CHECK_INTERFACE(IAudioFlinger, data, reply); 999 uint32_t stream = data.readInt32(); 1000 audio_io_handle_t output = (audio_io_handle_t) data.readInt32(); 1001 reply->writeInt32(setStreamOutput((audio_stream_type_t) stream, output)); 1002 return NO_ERROR; 1003 } break; 1004 case SET_VOICE_VOLUME: { 1005 CHECK_INTERFACE(IAudioFlinger, data, reply); 1006 float volume = data.readFloat(); 1007 reply->writeInt32( setVoiceVolume(volume) ); 1008 return NO_ERROR; 1009 } break; 1010 case GET_RENDER_POSITION: { 1011 CHECK_INTERFACE(IAudioFlinger, data, reply); 1012 audio_io_handle_t output = (audio_io_handle_t) data.readInt32(); 1013 size_t halFrames; 1014 size_t dspFrames; 1015 status_t status = getRenderPosition(&halFrames, &dspFrames, output); 1016 reply->writeInt32(status); 1017 if (status == NO_ERROR) { 1018 reply->writeInt32(halFrames); 1019 reply->writeInt32(dspFrames); 1020 } 1021 return NO_ERROR; 1022 } 1023 case GET_INPUT_FRAMES_LOST: { 1024 CHECK_INTERFACE(IAudioFlinger, data, reply); 1025 audio_io_handle_t ioHandle = (audio_io_handle_t) data.readInt32(); 1026 reply->writeInt32(getInputFramesLost(ioHandle)); 1027 return NO_ERROR; 1028 } break; 1029 case NEW_AUDIO_SESSION_ID: { 1030 CHECK_INTERFACE(IAudioFlinger, data, reply); 1031 reply->writeInt32(newAudioSessionId()); 1032 return NO_ERROR; 1033 } break; 1034 case ACQUIRE_AUDIO_SESSION_ID: { 1035 CHECK_INTERFACE(IAudioFlinger, data, reply); 1036 int audioSession = data.readInt32(); 1037 acquireAudioSessionId(audioSession); 1038 return NO_ERROR; 1039 } break; 1040 case RELEASE_AUDIO_SESSION_ID: { 1041 CHECK_INTERFACE(IAudioFlinger, data, reply); 1042 int audioSession = data.readInt32(); 1043 releaseAudioSessionId(audioSession); 1044 return NO_ERROR; 1045 } break; 1046 case QUERY_NUM_EFFECTS: { 1047 CHECK_INTERFACE(IAudioFlinger, data, reply); 1048 uint32_t numEffects; 1049 status_t status = queryNumberEffects(&numEffects); 1050 reply->writeInt32(status); 1051 if (status == NO_ERROR) { 1052 reply->writeInt32((int32_t)numEffects); 1053 } 1054 return NO_ERROR; 1055 } 1056 case QUERY_EFFECT: { 1057 CHECK_INTERFACE(IAudioFlinger, data, reply); 1058 effect_descriptor_t desc; 1059 status_t status = queryEffect(data.readInt32(), &desc); 1060 reply->writeInt32(status); 1061 if (status == NO_ERROR) { 1062 reply->write(&desc, sizeof(effect_descriptor_t)); 1063 } 1064 return NO_ERROR; 1065 } 1066 case GET_EFFECT_DESCRIPTOR: { 1067 CHECK_INTERFACE(IAudioFlinger, data, reply); 1068 effect_uuid_t uuid; 1069 data.read(&uuid, sizeof(effect_uuid_t)); 1070 effect_descriptor_t desc; 1071 status_t status = getEffectDescriptor(&uuid, &desc); 1072 reply->writeInt32(status); 1073 if (status == NO_ERROR) { 1074 reply->write(&desc, sizeof(effect_descriptor_t)); 1075 } 1076 return NO_ERROR; 1077 } 1078 case CREATE_EFFECT: { 1079 CHECK_INTERFACE(IAudioFlinger, data, reply); 1080 effect_descriptor_t desc; 1081 data.read(&desc, sizeof(effect_descriptor_t)); 1082 sp<IEffectClient> client = interface_cast<IEffectClient>(data.readStrongBinder()); 1083 int32_t priority = data.readInt32(); 1084 audio_io_handle_t output = (audio_io_handle_t) data.readInt32(); 1085 int sessionId = data.readInt32(); 1086 status_t status; 1087 int id; 1088 int enabled; 1089 1090 sp<IEffect> effect = createEffect(&desc, client, priority, output, sessionId, 1091 &status, &id, &enabled); 1092 reply->writeInt32(status); 1093 reply->writeInt32(id); 1094 reply->writeInt32(enabled); 1095 reply->writeStrongBinder(effect->asBinder()); 1096 reply->write(&desc, sizeof(effect_descriptor_t)); 1097 return NO_ERROR; 1098 } break; 1099 case MOVE_EFFECTS: { 1100 CHECK_INTERFACE(IAudioFlinger, data, reply); 1101 int session = data.readInt32(); 1102 audio_io_handle_t srcOutput = (audio_io_handle_t) data.readInt32(); 1103 audio_io_handle_t dstOutput = (audio_io_handle_t) data.readInt32(); 1104 reply->writeInt32(moveEffects(session, srcOutput, dstOutput)); 1105 return NO_ERROR; 1106 } break; 1107 case LOAD_HW_MODULE: { 1108 CHECK_INTERFACE(IAudioFlinger, data, reply); 1109 reply->writeInt32(loadHwModule(data.readCString())); 1110 return NO_ERROR; 1111 } break; 1112 case GET_PRIMARY_OUTPUT_SAMPLING_RATE: { 1113 CHECK_INTERFACE(IAudioFlinger, data, reply); 1114 reply->writeInt32(getPrimaryOutputSamplingRate()); 1115 return NO_ERROR; 1116 } break; 1117 case GET_PRIMARY_OUTPUT_FRAME_COUNT: { 1118 CHECK_INTERFACE(IAudioFlinger, data, reply); 1119 reply->writeInt32(getPrimaryOutputFrameCount()); 1120 return NO_ERROR; 1121 } break; 1122 case SET_LOW_RAM_DEVICE: { 1123 CHECK_INTERFACE(IAudioFlinger, data, reply); 1124 bool isLowRamDevice = data.readInt32() != 0; 1125 reply->writeInt32(setLowRamDevice(isLowRamDevice)); 1126 return NO_ERROR; 1127 } break; 1128 default: 1129 return BBinder::onTransact(code, data, reply, flags); 1130 } 1131 } 1132 1133 // ---------------------------------------------------------------------------- 1134 1135 }; // namespace android 1136
