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/IPCThreadState.h> 26 #include <binder/Parcel.h> 27 #include <media/TimeCheck.h> 28 #include <mediautils/ServiceUtilities.h> 29 #include "IAudioFlinger.h" 30 31 namespace android { 32 33 enum { 34 CREATE_TRACK = IBinder::FIRST_CALL_TRANSACTION, 35 CREATE_RECORD, 36 SAMPLE_RATE, 37 RESERVED, // obsolete, was CHANNEL_COUNT 38 FORMAT, 39 FRAME_COUNT, 40 LATENCY, 41 SET_MASTER_VOLUME, 42 SET_MASTER_MUTE, 43 MASTER_VOLUME, 44 MASTER_MUTE, 45 SET_STREAM_VOLUME, 46 SET_STREAM_MUTE, 47 STREAM_VOLUME, 48 STREAM_MUTE, 49 SET_MODE, 50 SET_MIC_MUTE, 51 GET_MIC_MUTE, 52 SET_RECORD_SILENCED, 53 SET_PARAMETERS, 54 GET_PARAMETERS, 55 REGISTER_CLIENT, 56 GET_INPUTBUFFERSIZE, 57 OPEN_OUTPUT, 58 OPEN_DUPLICATE_OUTPUT, 59 CLOSE_OUTPUT, 60 SUSPEND_OUTPUT, 61 RESTORE_OUTPUT, 62 OPEN_INPUT, 63 CLOSE_INPUT, 64 INVALIDATE_STREAM, 65 SET_VOICE_VOLUME, 66 GET_RENDER_POSITION, 67 GET_INPUT_FRAMES_LOST, 68 NEW_AUDIO_UNIQUE_ID, 69 ACQUIRE_AUDIO_SESSION_ID, 70 RELEASE_AUDIO_SESSION_ID, 71 QUERY_NUM_EFFECTS, 72 QUERY_EFFECT, 73 GET_EFFECT_DESCRIPTOR, 74 CREATE_EFFECT, 75 MOVE_EFFECTS, 76 LOAD_HW_MODULE, 77 GET_PRIMARY_OUTPUT_SAMPLING_RATE, 78 GET_PRIMARY_OUTPUT_FRAME_COUNT, 79 SET_LOW_RAM_DEVICE, 80 LIST_AUDIO_PORTS, 81 GET_AUDIO_PORT, 82 CREATE_AUDIO_PATCH, 83 RELEASE_AUDIO_PATCH, 84 LIST_AUDIO_PATCHES, 85 SET_AUDIO_PORT_CONFIG, 86 GET_AUDIO_HW_SYNC_FOR_SESSION, 87 SYSTEM_READY, 88 FRAME_COUNT_HAL, 89 GET_MICROPHONES, 90 SET_MASTER_BALANCE, 91 GET_MASTER_BALANCE, 92 SET_EFFECT_SUSPENDED, 93 }; 94 95 #define MAX_ITEMS_PER_LIST 1024 96 97 class BpAudioFlinger : public BpInterface<IAudioFlinger> 98 { 99 public: 100 explicit BpAudioFlinger(const sp<IBinder>& impl) 101 : BpInterface<IAudioFlinger>(impl) 102 { 103 } 104 105 virtual sp<IAudioTrack> createTrack(const CreateTrackInput& input, 106 CreateTrackOutput& output, 107 status_t *status) 108 { 109 Parcel data, reply; 110 sp<IAudioTrack> track; 111 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 112 113 if (status == nullptr) { 114 return track; 115 } 116 117 input.writeToParcel(&data); 118 119 status_t lStatus = remote()->transact(CREATE_TRACK, data, &reply); 120 if (lStatus != NO_ERROR) { 121 ALOGE("createTrack transaction error %d", lStatus); 122 *status = DEAD_OBJECT; 123 return track; 124 } 125 *status = reply.readInt32(); 126 if (*status != NO_ERROR) { 127 ALOGE("createTrack returned error %d", *status); 128 return track; 129 } 130 track = interface_cast<IAudioTrack>(reply.readStrongBinder()); 131 if (track == 0) { 132 ALOGE("createTrack returned an NULL IAudioTrack with status OK"); 133 *status = DEAD_OBJECT; 134 return track; 135 } 136 output.readFromParcel(&reply); 137 return track; 138 } 139 140 virtual sp<media::IAudioRecord> createRecord(const CreateRecordInput& input, 141 CreateRecordOutput& output, 142 status_t *status) 143 { 144 Parcel data, reply; 145 sp<media::IAudioRecord> record; 146 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 147 148 if (status == nullptr) { 149 return record; 150 } 151 152 input.writeToParcel(&data); 153 154 status_t lStatus = remote()->transact(CREATE_RECORD, data, &reply); 155 if (lStatus != NO_ERROR) { 156 ALOGE("createRecord transaction error %d", lStatus); 157 *status = DEAD_OBJECT; 158 return record; 159 } 160 *status = reply.readInt32(); 161 if (*status != NO_ERROR) { 162 ALOGE("createRecord returned error %d", *status); 163 return record; 164 } 165 166 record = interface_cast<media::IAudioRecord>(reply.readStrongBinder()); 167 if (record == 0) { 168 ALOGE("createRecord returned a NULL IAudioRecord with status OK"); 169 *status = DEAD_OBJECT; 170 return record; 171 } 172 output.readFromParcel(&reply); 173 return record; 174 } 175 176 virtual uint32_t sampleRate(audio_io_handle_t ioHandle) const 177 { 178 Parcel data, reply; 179 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 180 data.writeInt32((int32_t) ioHandle); 181 remote()->transact(SAMPLE_RATE, data, &reply); 182 return reply.readInt32(); 183 } 184 185 // RESERVED for channelCount() 186 187 virtual audio_format_t format(audio_io_handle_t output) const 188 { 189 Parcel data, reply; 190 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 191 data.writeInt32((int32_t) output); 192 remote()->transact(FORMAT, data, &reply); 193 return (audio_format_t) reply.readInt32(); 194 } 195 196 virtual size_t frameCount(audio_io_handle_t ioHandle) const 197 { 198 Parcel data, reply; 199 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 200 data.writeInt32((int32_t) ioHandle); 201 remote()->transact(FRAME_COUNT, data, &reply); 202 return reply.readInt64(); 203 } 204 205 virtual uint32_t latency(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(LATENCY, data, &reply); 211 return reply.readInt32(); 212 } 213 214 virtual status_t setMasterVolume(float value) 215 { 216 Parcel data, reply; 217 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 218 data.writeFloat(value); 219 remote()->transact(SET_MASTER_VOLUME, data, &reply); 220 return reply.readInt32(); 221 } 222 223 virtual status_t setMasterMute(bool muted) 224 { 225 Parcel data, reply; 226 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 227 data.writeInt32(muted); 228 remote()->transact(SET_MASTER_MUTE, data, &reply); 229 return reply.readInt32(); 230 } 231 232 virtual float masterVolume() const 233 { 234 Parcel data, reply; 235 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 236 remote()->transact(MASTER_VOLUME, data, &reply); 237 return reply.readFloat(); 238 } 239 240 virtual bool masterMute() const 241 { 242 Parcel data, reply; 243 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 244 remote()->transact(MASTER_MUTE, data, &reply); 245 return reply.readInt32(); 246 } 247 248 status_t setMasterBalance(float balance) override 249 { 250 Parcel data, reply; 251 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 252 data.writeFloat(balance); 253 status_t status = remote()->transact(SET_MASTER_BALANCE, data, &reply); 254 if (status != NO_ERROR) { 255 return status; 256 } 257 return reply.readInt32(); 258 } 259 260 status_t getMasterBalance(float *balance) const override 261 { 262 Parcel data, reply; 263 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 264 status_t status = remote()->transact(GET_MASTER_BALANCE, data, &reply); 265 if (status != NO_ERROR) { 266 return status; 267 } 268 status = (status_t)reply.readInt32(); 269 if (status != NO_ERROR) { 270 return status; 271 } 272 *balance = reply.readFloat(); 273 return NO_ERROR; 274 } 275 276 virtual status_t setStreamVolume(audio_stream_type_t stream, float value, 277 audio_io_handle_t output) 278 { 279 Parcel data, reply; 280 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 281 data.writeInt32((int32_t) stream); 282 data.writeFloat(value); 283 data.writeInt32((int32_t) output); 284 remote()->transact(SET_STREAM_VOLUME, data, &reply); 285 return reply.readInt32(); 286 } 287 288 virtual status_t setStreamMute(audio_stream_type_t stream, bool muted) 289 { 290 Parcel data, reply; 291 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 292 data.writeInt32((int32_t) stream); 293 data.writeInt32(muted); 294 remote()->transact(SET_STREAM_MUTE, data, &reply); 295 return reply.readInt32(); 296 } 297 298 virtual float streamVolume(audio_stream_type_t stream, audio_io_handle_t output) const 299 { 300 Parcel data, reply; 301 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 302 data.writeInt32((int32_t) stream); 303 data.writeInt32((int32_t) output); 304 remote()->transact(STREAM_VOLUME, data, &reply); 305 return reply.readFloat(); 306 } 307 308 virtual bool streamMute(audio_stream_type_t stream) const 309 { 310 Parcel data, reply; 311 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 312 data.writeInt32((int32_t) stream); 313 remote()->transact(STREAM_MUTE, data, &reply); 314 return reply.readInt32(); 315 } 316 317 virtual status_t setMode(audio_mode_t mode) 318 { 319 Parcel data, reply; 320 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 321 data.writeInt32(mode); 322 remote()->transact(SET_MODE, data, &reply); 323 return reply.readInt32(); 324 } 325 326 virtual status_t setMicMute(bool state) 327 { 328 Parcel data, reply; 329 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 330 data.writeInt32(state); 331 remote()->transact(SET_MIC_MUTE, data, &reply); 332 return reply.readInt32(); 333 } 334 335 virtual bool getMicMute() const 336 { 337 Parcel data, reply; 338 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 339 remote()->transact(GET_MIC_MUTE, data, &reply); 340 return reply.readInt32(); 341 } 342 343 virtual void setRecordSilenced(uid_t uid, bool silenced) 344 { 345 Parcel data, reply; 346 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 347 data.writeInt32(uid); 348 data.writeInt32(silenced ? 1 : 0); 349 remote()->transact(SET_RECORD_SILENCED, data, &reply); 350 } 351 352 virtual status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs) 353 { 354 Parcel data, reply; 355 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 356 data.writeInt32((int32_t) ioHandle); 357 data.writeString8(keyValuePairs); 358 remote()->transact(SET_PARAMETERS, data, &reply); 359 return reply.readInt32(); 360 } 361 362 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) const 363 { 364 Parcel data, reply; 365 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 366 data.writeInt32((int32_t) ioHandle); 367 data.writeString8(keys); 368 remote()->transact(GET_PARAMETERS, data, &reply); 369 return reply.readString8(); 370 } 371 372 virtual void registerClient(const sp<IAudioFlingerClient>& client) 373 { 374 Parcel data, reply; 375 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 376 data.writeStrongBinder(IInterface::asBinder(client)); 377 remote()->transact(REGISTER_CLIENT, data, &reply); 378 } 379 380 virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, 381 audio_channel_mask_t channelMask) const 382 { 383 Parcel data, reply; 384 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 385 data.writeInt32(sampleRate); 386 data.writeInt32(format); 387 data.writeInt32(channelMask); 388 remote()->transact(GET_INPUTBUFFERSIZE, data, &reply); 389 return reply.readInt64(); 390 } 391 392 virtual status_t openOutput(audio_module_handle_t module, 393 audio_io_handle_t *output, 394 audio_config_t *config, 395 audio_devices_t *devices, 396 const String8& address, 397 uint32_t *latencyMs, 398 audio_output_flags_t flags) 399 { 400 if (output == NULL || config == NULL || devices == NULL || latencyMs == NULL) { 401 return BAD_VALUE; 402 } 403 Parcel data, reply; 404 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 405 data.writeInt32(module); 406 data.write(config, sizeof(audio_config_t)); 407 data.writeInt32(*devices); 408 data.writeString8(address); 409 data.writeInt32((int32_t) flags); 410 status_t status = remote()->transact(OPEN_OUTPUT, data, &reply); 411 if (status != NO_ERROR) { 412 *output = AUDIO_IO_HANDLE_NONE; 413 return status; 414 } 415 status = (status_t)reply.readInt32(); 416 if (status != NO_ERROR) { 417 *output = AUDIO_IO_HANDLE_NONE; 418 return status; 419 } 420 *output = (audio_io_handle_t)reply.readInt32(); 421 ALOGV("openOutput() returned output, %d", *output); 422 reply.read(config, sizeof(audio_config_t)); 423 *devices = (audio_devices_t)reply.readInt32(); 424 *latencyMs = reply.readInt32(); 425 return NO_ERROR; 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 status_t openInput(audio_module_handle_t module, 467 audio_io_handle_t *input, 468 audio_config_t *config, 469 audio_devices_t *device, 470 const String8& address, 471 audio_source_t source, 472 audio_input_flags_t flags) 473 { 474 if (input == NULL || config == NULL || device == NULL) { 475 return BAD_VALUE; 476 } 477 Parcel data, reply; 478 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 479 data.writeInt32(module); 480 data.writeInt32(*input); 481 data.write(config, sizeof(audio_config_t)); 482 data.writeInt32(*device); 483 data.writeString8(address); 484 data.writeInt32(source); 485 data.writeInt32(flags); 486 status_t status = remote()->transact(OPEN_INPUT, data, &reply); 487 if (status != NO_ERROR) { 488 *input = AUDIO_IO_HANDLE_NONE; 489 return status; 490 } 491 status = (status_t)reply.readInt32(); 492 if (status != NO_ERROR) { 493 *input = AUDIO_IO_HANDLE_NONE; 494 return status; 495 } 496 *input = (audio_io_handle_t)reply.readInt32(); 497 reply.read(config, sizeof(audio_config_t)); 498 *device = (audio_devices_t)reply.readInt32(); 499 return NO_ERROR; 500 } 501 502 virtual status_t closeInput(int input) 503 { 504 Parcel data, reply; 505 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 506 data.writeInt32(input); 507 remote()->transact(CLOSE_INPUT, data, &reply); 508 return reply.readInt32(); 509 } 510 511 virtual status_t invalidateStream(audio_stream_type_t stream) 512 { 513 Parcel data, reply; 514 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 515 data.writeInt32((int32_t) stream); 516 remote()->transact(INVALIDATE_STREAM, data, &reply); 517 return reply.readInt32(); 518 } 519 520 virtual status_t setVoiceVolume(float volume) 521 { 522 Parcel data, reply; 523 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 524 data.writeFloat(volume); 525 remote()->transact(SET_VOICE_VOLUME, data, &reply); 526 return reply.readInt32(); 527 } 528 529 virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames, 530 audio_io_handle_t output) const 531 { 532 Parcel data, reply; 533 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 534 data.writeInt32((int32_t) output); 535 remote()->transact(GET_RENDER_POSITION, data, &reply); 536 status_t status = reply.readInt32(); 537 if (status == NO_ERROR) { 538 uint32_t tmp = reply.readInt32(); 539 if (halFrames != NULL) { 540 *halFrames = tmp; 541 } 542 tmp = reply.readInt32(); 543 if (dspFrames != NULL) { 544 *dspFrames = tmp; 545 } 546 } 547 return status; 548 } 549 550 virtual uint32_t getInputFramesLost(audio_io_handle_t ioHandle) const 551 { 552 Parcel data, reply; 553 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 554 data.writeInt32((int32_t) ioHandle); 555 status_t status = remote()->transact(GET_INPUT_FRAMES_LOST, data, &reply); 556 if (status != NO_ERROR) { 557 return 0; 558 } 559 return (uint32_t) reply.readInt32(); 560 } 561 562 virtual audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use) 563 { 564 Parcel data, reply; 565 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 566 data.writeInt32((int32_t) use); 567 status_t status = remote()->transact(NEW_AUDIO_UNIQUE_ID, data, &reply); 568 audio_unique_id_t id = AUDIO_UNIQUE_ID_ALLOCATE; 569 if (status == NO_ERROR) { 570 id = reply.readInt32(); 571 } 572 return id; 573 } 574 575 virtual void acquireAudioSessionId(audio_session_t audioSession, int pid) 576 { 577 Parcel data, reply; 578 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 579 data.writeInt32(audioSession); 580 data.writeInt32(pid); 581 remote()->transact(ACQUIRE_AUDIO_SESSION_ID, data, &reply); 582 } 583 584 virtual void releaseAudioSessionId(audio_session_t audioSession, int pid) 585 { 586 Parcel data, reply; 587 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 588 data.writeInt32(audioSession); 589 data.writeInt32(pid); 590 remote()->transact(RELEASE_AUDIO_SESSION_ID, data, &reply); 591 } 592 593 virtual status_t queryNumberEffects(uint32_t *numEffects) const 594 { 595 Parcel data, reply; 596 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 597 status_t status = remote()->transact(QUERY_NUM_EFFECTS, data, &reply); 598 if (status != NO_ERROR) { 599 return status; 600 } 601 status = reply.readInt32(); 602 if (status != NO_ERROR) { 603 return status; 604 } 605 if (numEffects != NULL) { 606 *numEffects = (uint32_t)reply.readInt32(); 607 } 608 return NO_ERROR; 609 } 610 611 virtual status_t queryEffect(uint32_t index, effect_descriptor_t *pDescriptor) const 612 { 613 if (pDescriptor == NULL) { 614 return BAD_VALUE; 615 } 616 Parcel data, reply; 617 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 618 data.writeInt32(index); 619 status_t status = remote()->transact(QUERY_EFFECT, data, &reply); 620 if (status != NO_ERROR) { 621 return status; 622 } 623 status = reply.readInt32(); 624 if (status != NO_ERROR) { 625 return status; 626 } 627 reply.read(pDescriptor, sizeof(effect_descriptor_t)); 628 return NO_ERROR; 629 } 630 631 virtual status_t getEffectDescriptor(const effect_uuid_t *pUuid, 632 const effect_uuid_t *pType, 633 uint32_t preferredTypeFlag, 634 effect_descriptor_t *pDescriptor) const 635 { 636 if (pUuid == NULL || pType == NULL || pDescriptor == NULL) { 637 return BAD_VALUE; 638 } 639 Parcel data, reply; 640 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 641 data.write(pUuid, sizeof(effect_uuid_t)); 642 data.write(pType, sizeof(effect_uuid_t)); 643 data.writeUint32(preferredTypeFlag); 644 status_t status = remote()->transact(GET_EFFECT_DESCRIPTOR, data, &reply); 645 if (status != NO_ERROR) { 646 return status; 647 } 648 status = reply.readInt32(); 649 if (status != NO_ERROR) { 650 return status; 651 } 652 reply.read(pDescriptor, sizeof(effect_descriptor_t)); 653 return NO_ERROR; 654 } 655 656 virtual sp<IEffect> createEffect( 657 effect_descriptor_t *pDesc, 658 const sp<IEffectClient>& client, 659 int32_t priority, 660 audio_io_handle_t output, 661 audio_session_t sessionId, 662 const String16& opPackageName, 663 pid_t pid, 664 status_t *status, 665 int *id, 666 int *enabled) 667 { 668 Parcel data, reply; 669 sp<IEffect> effect; 670 671 if (pDesc == NULL) { 672 if (status != NULL) { 673 *status = BAD_VALUE; 674 } 675 return effect; 676 } 677 678 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 679 data.write(pDesc, sizeof(effect_descriptor_t)); 680 data.writeStrongBinder(IInterface::asBinder(client)); 681 data.writeInt32(priority); 682 data.writeInt32((int32_t) output); 683 data.writeInt32(sessionId); 684 data.writeString16(opPackageName); 685 data.writeInt32((int32_t) pid); 686 687 status_t lStatus = remote()->transact(CREATE_EFFECT, data, &reply); 688 if (lStatus != NO_ERROR) { 689 ALOGE("createEffect error: %s", strerror(-lStatus)); 690 } else { 691 lStatus = reply.readInt32(); 692 int tmp = reply.readInt32(); 693 if (id != NULL) { 694 *id = tmp; 695 } 696 tmp = reply.readInt32(); 697 if (enabled != NULL) { 698 *enabled = tmp; 699 } 700 effect = interface_cast<IEffect>(reply.readStrongBinder()); 701 reply.read(pDesc, sizeof(effect_descriptor_t)); 702 } 703 if (status != NULL) { 704 *status = lStatus; 705 } 706 707 return effect; 708 } 709 710 virtual status_t moveEffects(audio_session_t session, audio_io_handle_t srcOutput, 711 audio_io_handle_t dstOutput) 712 { 713 Parcel data, reply; 714 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 715 data.writeInt32(session); 716 data.writeInt32((int32_t) srcOutput); 717 data.writeInt32((int32_t) dstOutput); 718 remote()->transact(MOVE_EFFECTS, data, &reply); 719 return reply.readInt32(); 720 } 721 722 virtual void setEffectSuspended(int effectId, 723 audio_session_t sessionId, 724 bool suspended) 725 { 726 Parcel data, reply; 727 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 728 data.writeInt32(effectId); 729 data.writeInt32(sessionId); 730 data.writeInt32(suspended ? 1 : 0); 731 remote()->transact(SET_EFFECT_SUSPENDED, data, &reply); 732 } 733 734 virtual audio_module_handle_t loadHwModule(const char *name) 735 { 736 Parcel data, reply; 737 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 738 data.writeCString(name); 739 remote()->transact(LOAD_HW_MODULE, data, &reply); 740 return (audio_module_handle_t) reply.readInt32(); 741 } 742 743 virtual uint32_t getPrimaryOutputSamplingRate() 744 { 745 Parcel data, reply; 746 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 747 remote()->transact(GET_PRIMARY_OUTPUT_SAMPLING_RATE, data, &reply); 748 return reply.readInt32(); 749 } 750 751 virtual size_t getPrimaryOutputFrameCount() 752 { 753 Parcel data, reply; 754 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 755 remote()->transact(GET_PRIMARY_OUTPUT_FRAME_COUNT, data, &reply); 756 return reply.readInt64(); 757 } 758 759 virtual status_t setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) override 760 { 761 Parcel data, reply; 762 763 static_assert(NO_ERROR == 0, "NO_ERROR must be 0"); 764 return data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()) 765 ?: data.writeInt32((int) isLowRamDevice) 766 ?: data.writeInt64(totalMemory) 767 ?: remote()->transact(SET_LOW_RAM_DEVICE, data, &reply) 768 ?: reply.readInt32(); 769 } 770 771 virtual status_t listAudioPorts(unsigned int *num_ports, 772 struct audio_port *ports) 773 { 774 if (num_ports == NULL || *num_ports == 0 || ports == NULL) { 775 return BAD_VALUE; 776 } 777 Parcel data, reply; 778 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 779 data.writeInt32(*num_ports); 780 status_t status = remote()->transact(LIST_AUDIO_PORTS, data, &reply); 781 if (status != NO_ERROR || 782 (status = (status_t)reply.readInt32()) != NO_ERROR) { 783 return status; 784 } 785 *num_ports = (unsigned int)reply.readInt32(); 786 reply.read(ports, *num_ports * sizeof(struct audio_port)); 787 return status; 788 } 789 virtual status_t getAudioPort(struct audio_port *port) 790 { 791 if (port == NULL) { 792 return BAD_VALUE; 793 } 794 Parcel data, reply; 795 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 796 data.write(port, sizeof(struct audio_port)); 797 status_t status = remote()->transact(GET_AUDIO_PORT, data, &reply); 798 if (status != NO_ERROR || 799 (status = (status_t)reply.readInt32()) != NO_ERROR) { 800 return status; 801 } 802 reply.read(port, sizeof(struct audio_port)); 803 return status; 804 } 805 virtual status_t createAudioPatch(const struct audio_patch *patch, 806 audio_patch_handle_t *handle) 807 { 808 if (patch == NULL || handle == NULL) { 809 return BAD_VALUE; 810 } 811 Parcel data, reply; 812 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 813 data.write(patch, sizeof(struct audio_patch)); 814 data.write(handle, sizeof(audio_patch_handle_t)); 815 status_t status = remote()->transact(CREATE_AUDIO_PATCH, data, &reply); 816 if (status != NO_ERROR || 817 (status = (status_t)reply.readInt32()) != NO_ERROR) { 818 return status; 819 } 820 reply.read(handle, sizeof(audio_patch_handle_t)); 821 return status; 822 } 823 virtual status_t releaseAudioPatch(audio_patch_handle_t handle) 824 { 825 Parcel data, reply; 826 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 827 data.write(&handle, sizeof(audio_patch_handle_t)); 828 status_t status = remote()->transact(RELEASE_AUDIO_PATCH, data, &reply); 829 if (status != NO_ERROR) { 830 status = (status_t)reply.readInt32(); 831 } 832 return status; 833 } 834 virtual status_t listAudioPatches(unsigned int *num_patches, 835 struct audio_patch *patches) 836 { 837 if (num_patches == NULL || *num_patches == 0 || patches == NULL) { 838 return BAD_VALUE; 839 } 840 Parcel data, reply; 841 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 842 data.writeInt32(*num_patches); 843 status_t status = remote()->transact(LIST_AUDIO_PATCHES, data, &reply); 844 if (status != NO_ERROR || 845 (status = (status_t)reply.readInt32()) != NO_ERROR) { 846 return status; 847 } 848 *num_patches = (unsigned int)reply.readInt32(); 849 reply.read(patches, *num_patches * sizeof(struct audio_patch)); 850 return status; 851 } 852 virtual status_t setAudioPortConfig(const struct audio_port_config *config) 853 { 854 if (config == NULL) { 855 return BAD_VALUE; 856 } 857 Parcel data, reply; 858 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 859 data.write(config, sizeof(struct audio_port_config)); 860 status_t status = remote()->transact(SET_AUDIO_PORT_CONFIG, data, &reply); 861 if (status != NO_ERROR) { 862 status = (status_t)reply.readInt32(); 863 } 864 return status; 865 } 866 virtual audio_hw_sync_t getAudioHwSyncForSession(audio_session_t sessionId) 867 { 868 Parcel data, reply; 869 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 870 data.writeInt32(sessionId); 871 status_t status = remote()->transact(GET_AUDIO_HW_SYNC_FOR_SESSION, data, &reply); 872 if (status != NO_ERROR) { 873 return AUDIO_HW_SYNC_INVALID; 874 } 875 return (audio_hw_sync_t)reply.readInt32(); 876 } 877 virtual status_t systemReady() 878 { 879 Parcel data, reply; 880 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 881 return remote()->transact(SYSTEM_READY, data, &reply, IBinder::FLAG_ONEWAY); 882 } 883 virtual size_t frameCountHAL(audio_io_handle_t ioHandle) const 884 { 885 Parcel data, reply; 886 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 887 data.writeInt32((int32_t) ioHandle); 888 status_t status = remote()->transact(FRAME_COUNT_HAL, data, &reply); 889 if (status != NO_ERROR) { 890 return 0; 891 } 892 return reply.readInt64(); 893 } 894 virtual status_t getMicrophones(std::vector<media::MicrophoneInfo> *microphones) 895 { 896 Parcel data, reply; 897 data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); 898 status_t status = remote()->transact(GET_MICROPHONES, data, &reply); 899 if (status != NO_ERROR || 900 (status = (status_t)reply.readInt32()) != NO_ERROR) { 901 return status; 902 } 903 status = reply.readParcelableVector(microphones); 904 return status; 905 } 906 }; 907 908 IMPLEMENT_META_INTERFACE(AudioFlinger, "android.media.IAudioFlinger"); 909 910 // ---------------------------------------------------------------------- 911 912 status_t BnAudioFlinger::onTransact( 913 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 914 { 915 // make sure transactions reserved to AudioPolicyManager do not come from other processes 916 switch (code) { 917 case SET_STREAM_VOLUME: 918 case SET_STREAM_MUTE: 919 case OPEN_OUTPUT: 920 case OPEN_DUPLICATE_OUTPUT: 921 case CLOSE_OUTPUT: 922 case SUSPEND_OUTPUT: 923 case RESTORE_OUTPUT: 924 case OPEN_INPUT: 925 case CLOSE_INPUT: 926 case INVALIDATE_STREAM: 927 case SET_VOICE_VOLUME: 928 case MOVE_EFFECTS: 929 case SET_EFFECT_SUSPENDED: 930 case LOAD_HW_MODULE: 931 case LIST_AUDIO_PORTS: 932 case GET_AUDIO_PORT: 933 case CREATE_AUDIO_PATCH: 934 case RELEASE_AUDIO_PATCH: 935 case LIST_AUDIO_PATCHES: 936 case SET_AUDIO_PORT_CONFIG: 937 case SET_RECORD_SILENCED: 938 ALOGW("%s: transaction %d received from PID %d", 939 __func__, code, IPCThreadState::self()->getCallingPid()); 940 // return status only for non void methods 941 switch (code) { 942 case SET_RECORD_SILENCED: 943 case SET_EFFECT_SUSPENDED: 944 break; 945 default: 946 reply->writeInt32(static_cast<int32_t> (INVALID_OPERATION)); 947 break; 948 } 949 return OK; 950 default: 951 break; 952 } 953 954 // make sure the following transactions come from system components 955 switch (code) { 956 case SET_MASTER_VOLUME: 957 case SET_MASTER_MUTE: 958 case SET_MODE: 959 case SET_MIC_MUTE: 960 case SET_LOW_RAM_DEVICE: 961 case SYSTEM_READY: { 962 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) { 963 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d", 964 __func__, code, IPCThreadState::self()->getCallingPid(), 965 IPCThreadState::self()->getCallingUid()); 966 // return status only for non void methods 967 switch (code) { 968 case SYSTEM_READY: 969 break; 970 default: 971 reply->writeInt32(static_cast<int32_t> (INVALID_OPERATION)); 972 break; 973 } 974 return OK; 975 } 976 } break; 977 default: 978 break; 979 } 980 981 // Whitelist of relevant events to trigger log merging. 982 // Log merging should activate during audio activity of any kind. This are considered the 983 // most relevant events. 984 // TODO should select more wisely the items from the list 985 switch (code) { 986 case CREATE_TRACK: 987 case CREATE_RECORD: 988 case SET_MASTER_VOLUME: 989 case SET_MASTER_MUTE: 990 case SET_MIC_MUTE: 991 case SET_PARAMETERS: 992 case CREATE_EFFECT: 993 case SYSTEM_READY: { 994 requestLogMerge(); 995 break; 996 } 997 default: 998 break; 999 } 1000 1001 std::string tag("IAudioFlinger command " + std::to_string(code)); 1002 TimeCheck check(tag.c_str()); 1003 1004 switch (code) { 1005 case CREATE_TRACK: { 1006 CHECK_INTERFACE(IAudioFlinger, data, reply); 1007 1008 CreateTrackInput input; 1009 if (input.readFromParcel((Parcel*)&data) != NO_ERROR) { 1010 reply->writeInt32(DEAD_OBJECT); 1011 return NO_ERROR; 1012 } 1013 1014 status_t status; 1015 CreateTrackOutput output; 1016 1017 sp<IAudioTrack> track= createTrack(input, 1018 output, 1019 &status); 1020 1021 LOG_ALWAYS_FATAL_IF((track != 0) != (status == NO_ERROR)); 1022 reply->writeInt32(status); 1023 if (status != NO_ERROR) { 1024 return NO_ERROR; 1025 } 1026 reply->writeStrongBinder(IInterface::asBinder(track)); 1027 output.writeToParcel(reply); 1028 return NO_ERROR; 1029 } break; 1030 case CREATE_RECORD: { 1031 CHECK_INTERFACE(IAudioFlinger, data, reply); 1032 1033 CreateRecordInput input; 1034 if (input.readFromParcel((Parcel*)&data) != NO_ERROR) { 1035 reply->writeInt32(DEAD_OBJECT); 1036 return NO_ERROR; 1037 } 1038 1039 status_t status; 1040 CreateRecordOutput output; 1041 1042 sp<media::IAudioRecord> record = createRecord(input, 1043 output, 1044 &status); 1045 1046 LOG_ALWAYS_FATAL_IF((record != 0) != (status == NO_ERROR)); 1047 reply->writeInt32(status); 1048 if (status != NO_ERROR) { 1049 return NO_ERROR; 1050 } 1051 reply->writeStrongBinder(IInterface::asBinder(record)); 1052 output.writeToParcel(reply); 1053 return NO_ERROR; 1054 } break; 1055 case SAMPLE_RATE: { 1056 CHECK_INTERFACE(IAudioFlinger, data, reply); 1057 reply->writeInt32( sampleRate((audio_io_handle_t) data.readInt32()) ); 1058 return NO_ERROR; 1059 } break; 1060 1061 // RESERVED for channelCount() 1062 1063 case FORMAT: { 1064 CHECK_INTERFACE(IAudioFlinger, data, reply); 1065 reply->writeInt32( format((audio_io_handle_t) data.readInt32()) ); 1066 return NO_ERROR; 1067 } break; 1068 case FRAME_COUNT: { 1069 CHECK_INTERFACE(IAudioFlinger, data, reply); 1070 reply->writeInt64( frameCount((audio_io_handle_t) data.readInt32()) ); 1071 return NO_ERROR; 1072 } break; 1073 case LATENCY: { 1074 CHECK_INTERFACE(IAudioFlinger, data, reply); 1075 reply->writeInt32( latency((audio_io_handle_t) data.readInt32()) ); 1076 return NO_ERROR; 1077 } break; 1078 case SET_MASTER_VOLUME: { 1079 CHECK_INTERFACE(IAudioFlinger, data, reply); 1080 reply->writeInt32( setMasterVolume(data.readFloat()) ); 1081 return NO_ERROR; 1082 } break; 1083 case SET_MASTER_MUTE: { 1084 CHECK_INTERFACE(IAudioFlinger, data, reply); 1085 reply->writeInt32( setMasterMute(data.readInt32()) ); 1086 return NO_ERROR; 1087 } break; 1088 case MASTER_VOLUME: { 1089 CHECK_INTERFACE(IAudioFlinger, data, reply); 1090 reply->writeFloat( masterVolume() ); 1091 return NO_ERROR; 1092 } break; 1093 case MASTER_MUTE: { 1094 CHECK_INTERFACE(IAudioFlinger, data, reply); 1095 reply->writeInt32( masterMute() ); 1096 return NO_ERROR; 1097 } break; 1098 case SET_MASTER_BALANCE: { 1099 CHECK_INTERFACE(IAudioFlinger, data, reply); 1100 reply->writeInt32( setMasterBalance(data.readFloat()) ); 1101 return NO_ERROR; 1102 } break; 1103 case GET_MASTER_BALANCE: { 1104 CHECK_INTERFACE(IAudioFlinger, data, reply); 1105 float f; 1106 const status_t status = getMasterBalance(&f); 1107 reply->writeInt32((int32_t)status); 1108 if (status == NO_ERROR) { 1109 (void)reply->writeFloat(f); 1110 } 1111 return NO_ERROR; 1112 } break; 1113 case SET_STREAM_VOLUME: { 1114 CHECK_INTERFACE(IAudioFlinger, data, reply); 1115 int stream = data.readInt32(); 1116 float volume = data.readFloat(); 1117 audio_io_handle_t output = (audio_io_handle_t) data.readInt32(); 1118 reply->writeInt32( setStreamVolume((audio_stream_type_t) stream, volume, output) ); 1119 return NO_ERROR; 1120 } break; 1121 case SET_STREAM_MUTE: { 1122 CHECK_INTERFACE(IAudioFlinger, data, reply); 1123 int stream = data.readInt32(); 1124 reply->writeInt32( setStreamMute((audio_stream_type_t) stream, data.readInt32()) ); 1125 return NO_ERROR; 1126 } break; 1127 case STREAM_VOLUME: { 1128 CHECK_INTERFACE(IAudioFlinger, data, reply); 1129 int stream = data.readInt32(); 1130 int output = data.readInt32(); 1131 reply->writeFloat( streamVolume((audio_stream_type_t) stream, output) ); 1132 return NO_ERROR; 1133 } break; 1134 case STREAM_MUTE: { 1135 CHECK_INTERFACE(IAudioFlinger, data, reply); 1136 int stream = data.readInt32(); 1137 reply->writeInt32( streamMute((audio_stream_type_t) stream) ); 1138 return NO_ERROR; 1139 } break; 1140 case SET_MODE: { 1141 CHECK_INTERFACE(IAudioFlinger, data, reply); 1142 audio_mode_t mode = (audio_mode_t) data.readInt32(); 1143 reply->writeInt32( setMode(mode) ); 1144 return NO_ERROR; 1145 } break; 1146 case SET_MIC_MUTE: { 1147 CHECK_INTERFACE(IAudioFlinger, data, reply); 1148 int state = data.readInt32(); 1149 reply->writeInt32( setMicMute(state) ); 1150 return NO_ERROR; 1151 } break; 1152 case GET_MIC_MUTE: { 1153 CHECK_INTERFACE(IAudioFlinger, data, reply); 1154 reply->writeInt32( getMicMute() ); 1155 return NO_ERROR; 1156 } break; 1157 case SET_RECORD_SILENCED: { 1158 CHECK_INTERFACE(IAudioFlinger, data, reply); 1159 uid_t uid = data.readInt32(); 1160 audio_source_t source; 1161 data.read(&source, sizeof(audio_source_t)); 1162 bool silenced = data.readInt32() == 1; 1163 setRecordSilenced(uid, silenced); 1164 return NO_ERROR; 1165 } break; 1166 case SET_PARAMETERS: { 1167 CHECK_INTERFACE(IAudioFlinger, data, reply); 1168 audio_io_handle_t ioHandle = (audio_io_handle_t) data.readInt32(); 1169 String8 keyValuePairs(data.readString8()); 1170 reply->writeInt32(setParameters(ioHandle, keyValuePairs)); 1171 return NO_ERROR; 1172 } break; 1173 case GET_PARAMETERS: { 1174 CHECK_INTERFACE(IAudioFlinger, data, reply); 1175 audio_io_handle_t ioHandle = (audio_io_handle_t) data.readInt32(); 1176 String8 keys(data.readString8()); 1177 reply->writeString8(getParameters(ioHandle, keys)); 1178 return NO_ERROR; 1179 } break; 1180 1181 case REGISTER_CLIENT: { 1182 CHECK_INTERFACE(IAudioFlinger, data, reply); 1183 sp<IAudioFlingerClient> client = interface_cast<IAudioFlingerClient>( 1184 data.readStrongBinder()); 1185 registerClient(client); 1186 return NO_ERROR; 1187 } break; 1188 case GET_INPUTBUFFERSIZE: { 1189 CHECK_INTERFACE(IAudioFlinger, data, reply); 1190 uint32_t sampleRate = data.readInt32(); 1191 audio_format_t format = (audio_format_t) data.readInt32(); 1192 audio_channel_mask_t channelMask = data.readInt32(); 1193 reply->writeInt64( getInputBufferSize(sampleRate, format, channelMask) ); 1194 return NO_ERROR; 1195 } break; 1196 case OPEN_OUTPUT: { 1197 CHECK_INTERFACE(IAudioFlinger, data, reply); 1198 audio_module_handle_t module = (audio_module_handle_t)data.readInt32(); 1199 audio_config_t config = {}; 1200 if (data.read(&config, sizeof(audio_config_t)) != NO_ERROR) { 1201 ALOGE("b/23905951"); 1202 } 1203 audio_devices_t devices = (audio_devices_t)data.readInt32(); 1204 String8 address(data.readString8()); 1205 audio_output_flags_t flags = (audio_output_flags_t) data.readInt32(); 1206 uint32_t latencyMs = 0; 1207 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE; 1208 status_t status = openOutput(module, &output, &config, 1209 &devices, address, &latencyMs, flags); 1210 ALOGV("OPEN_OUTPUT output, %d", output); 1211 reply->writeInt32((int32_t)status); 1212 if (status == NO_ERROR) { 1213 reply->writeInt32((int32_t)output); 1214 reply->write(&config, sizeof(audio_config_t)); 1215 reply->writeInt32(devices); 1216 reply->writeInt32(latencyMs); 1217 } 1218 return NO_ERROR; 1219 } break; 1220 case OPEN_DUPLICATE_OUTPUT: { 1221 CHECK_INTERFACE(IAudioFlinger, data, reply); 1222 audio_io_handle_t output1 = (audio_io_handle_t) data.readInt32(); 1223 audio_io_handle_t output2 = (audio_io_handle_t) data.readInt32(); 1224 reply->writeInt32((int32_t) openDuplicateOutput(output1, output2)); 1225 return NO_ERROR; 1226 } break; 1227 case CLOSE_OUTPUT: { 1228 CHECK_INTERFACE(IAudioFlinger, data, reply); 1229 reply->writeInt32(closeOutput((audio_io_handle_t) data.readInt32())); 1230 return NO_ERROR; 1231 } break; 1232 case SUSPEND_OUTPUT: { 1233 CHECK_INTERFACE(IAudioFlinger, data, reply); 1234 reply->writeInt32(suspendOutput((audio_io_handle_t) data.readInt32())); 1235 return NO_ERROR; 1236 } break; 1237 case RESTORE_OUTPUT: { 1238 CHECK_INTERFACE(IAudioFlinger, data, reply); 1239 reply->writeInt32(restoreOutput((audio_io_handle_t) data.readInt32())); 1240 return NO_ERROR; 1241 } break; 1242 case OPEN_INPUT: { 1243 CHECK_INTERFACE(IAudioFlinger, data, reply); 1244 audio_module_handle_t module = (audio_module_handle_t)data.readInt32(); 1245 audio_io_handle_t input = (audio_io_handle_t)data.readInt32(); 1246 audio_config_t config = {}; 1247 if (data.read(&config, sizeof(audio_config_t)) != NO_ERROR) { 1248 ALOGE("b/23905951"); 1249 } 1250 audio_devices_t device = (audio_devices_t)data.readInt32(); 1251 String8 address(data.readString8()); 1252 audio_source_t source = (audio_source_t)data.readInt32(); 1253 audio_input_flags_t flags = (audio_input_flags_t) data.readInt32(); 1254 1255 status_t status = openInput(module, &input, &config, 1256 &device, address, source, flags); 1257 reply->writeInt32((int32_t) status); 1258 if (status == NO_ERROR) { 1259 reply->writeInt32((int32_t) input); 1260 reply->write(&config, sizeof(audio_config_t)); 1261 reply->writeInt32(device); 1262 } 1263 return NO_ERROR; 1264 } break; 1265 case CLOSE_INPUT: { 1266 CHECK_INTERFACE(IAudioFlinger, data, reply); 1267 reply->writeInt32(closeInput((audio_io_handle_t) data.readInt32())); 1268 return NO_ERROR; 1269 } break; 1270 case INVALIDATE_STREAM: { 1271 CHECK_INTERFACE(IAudioFlinger, data, reply); 1272 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32(); 1273 reply->writeInt32(invalidateStream(stream)); 1274 return NO_ERROR; 1275 } break; 1276 case SET_VOICE_VOLUME: { 1277 CHECK_INTERFACE(IAudioFlinger, data, reply); 1278 float volume = data.readFloat(); 1279 reply->writeInt32( setVoiceVolume(volume) ); 1280 return NO_ERROR; 1281 } break; 1282 case GET_RENDER_POSITION: { 1283 CHECK_INTERFACE(IAudioFlinger, data, reply); 1284 audio_io_handle_t output = (audio_io_handle_t) data.readInt32(); 1285 uint32_t halFrames = 0; 1286 uint32_t dspFrames = 0; 1287 status_t status = getRenderPosition(&halFrames, &dspFrames, output); 1288 reply->writeInt32(status); 1289 if (status == NO_ERROR) { 1290 reply->writeInt32(halFrames); 1291 reply->writeInt32(dspFrames); 1292 } 1293 return NO_ERROR; 1294 } 1295 case GET_INPUT_FRAMES_LOST: { 1296 CHECK_INTERFACE(IAudioFlinger, data, reply); 1297 audio_io_handle_t ioHandle = (audio_io_handle_t) data.readInt32(); 1298 reply->writeInt32((int32_t) getInputFramesLost(ioHandle)); 1299 return NO_ERROR; 1300 } break; 1301 case NEW_AUDIO_UNIQUE_ID: { 1302 CHECK_INTERFACE(IAudioFlinger, data, reply); 1303 reply->writeInt32(newAudioUniqueId((audio_unique_id_use_t) data.readInt32())); 1304 return NO_ERROR; 1305 } break; 1306 case ACQUIRE_AUDIO_SESSION_ID: { 1307 CHECK_INTERFACE(IAudioFlinger, data, reply); 1308 audio_session_t audioSession = (audio_session_t) data.readInt32(); 1309 int pid = data.readInt32(); 1310 acquireAudioSessionId(audioSession, pid); 1311 return NO_ERROR; 1312 } break; 1313 case RELEASE_AUDIO_SESSION_ID: { 1314 CHECK_INTERFACE(IAudioFlinger, data, reply); 1315 audio_session_t audioSession = (audio_session_t) data.readInt32(); 1316 int pid = data.readInt32(); 1317 releaseAudioSessionId(audioSession, pid); 1318 return NO_ERROR; 1319 } break; 1320 case QUERY_NUM_EFFECTS: { 1321 CHECK_INTERFACE(IAudioFlinger, data, reply); 1322 uint32_t numEffects = 0; 1323 status_t status = queryNumberEffects(&numEffects); 1324 reply->writeInt32(status); 1325 if (status == NO_ERROR) { 1326 reply->writeInt32((int32_t)numEffects); 1327 } 1328 return NO_ERROR; 1329 } 1330 case QUERY_EFFECT: { 1331 CHECK_INTERFACE(IAudioFlinger, data, reply); 1332 effect_descriptor_t desc = {}; 1333 status_t status = queryEffect(data.readInt32(), &desc); 1334 reply->writeInt32(status); 1335 if (status == NO_ERROR) { 1336 reply->write(&desc, sizeof(effect_descriptor_t)); 1337 } 1338 return NO_ERROR; 1339 } 1340 case GET_EFFECT_DESCRIPTOR: { 1341 CHECK_INTERFACE(IAudioFlinger, data, reply); 1342 effect_uuid_t uuid; 1343 data.read(&uuid, sizeof(effect_uuid_t)); 1344 effect_uuid_t type; 1345 data.read(&type, sizeof(effect_uuid_t)); 1346 uint32_t preferredTypeFlag = data.readUint32(); 1347 effect_descriptor_t desc = {}; 1348 status_t status = getEffectDescriptor(&uuid, &type, preferredTypeFlag, &desc); 1349 reply->writeInt32(status); 1350 if (status == NO_ERROR) { 1351 reply->write(&desc, sizeof(effect_descriptor_t)); 1352 } 1353 return NO_ERROR; 1354 } 1355 case CREATE_EFFECT: { 1356 CHECK_INTERFACE(IAudioFlinger, data, reply); 1357 effect_descriptor_t desc = {}; 1358 if (data.read(&desc, sizeof(effect_descriptor_t)) != NO_ERROR) { 1359 ALOGE("b/23905951"); 1360 } 1361 sp<IEffectClient> client = interface_cast<IEffectClient>(data.readStrongBinder()); 1362 int32_t priority = data.readInt32(); 1363 audio_io_handle_t output = (audio_io_handle_t) data.readInt32(); 1364 audio_session_t sessionId = (audio_session_t) data.readInt32(); 1365 const String16 opPackageName = data.readString16(); 1366 pid_t pid = (pid_t)data.readInt32(); 1367 1368 status_t status = NO_ERROR; 1369 int id = 0; 1370 int enabled = 0; 1371 1372 sp<IEffect> effect = createEffect(&desc, client, priority, output, sessionId, 1373 opPackageName, pid, &status, &id, &enabled); 1374 reply->writeInt32(status); 1375 reply->writeInt32(id); 1376 reply->writeInt32(enabled); 1377 reply->writeStrongBinder(IInterface::asBinder(effect)); 1378 reply->write(&desc, sizeof(effect_descriptor_t)); 1379 return NO_ERROR; 1380 } break; 1381 case MOVE_EFFECTS: { 1382 CHECK_INTERFACE(IAudioFlinger, data, reply); 1383 audio_session_t session = (audio_session_t) data.readInt32(); 1384 audio_io_handle_t srcOutput = (audio_io_handle_t) data.readInt32(); 1385 audio_io_handle_t dstOutput = (audio_io_handle_t) data.readInt32(); 1386 reply->writeInt32(moveEffects(session, srcOutput, dstOutput)); 1387 return NO_ERROR; 1388 } break; 1389 case SET_EFFECT_SUSPENDED: { 1390 CHECK_INTERFACE(IAudioFlinger, data, reply); 1391 int effectId = data.readInt32(); 1392 audio_session_t sessionId = (audio_session_t) data.readInt32(); 1393 bool suspended = data.readInt32() == 1; 1394 setEffectSuspended(effectId, sessionId, suspended); 1395 return NO_ERROR; 1396 } break; 1397 case LOAD_HW_MODULE: { 1398 CHECK_INTERFACE(IAudioFlinger, data, reply); 1399 reply->writeInt32(loadHwModule(data.readCString())); 1400 return NO_ERROR; 1401 } break; 1402 case GET_PRIMARY_OUTPUT_SAMPLING_RATE: { 1403 CHECK_INTERFACE(IAudioFlinger, data, reply); 1404 reply->writeInt32(getPrimaryOutputSamplingRate()); 1405 return NO_ERROR; 1406 } break; 1407 case GET_PRIMARY_OUTPUT_FRAME_COUNT: { 1408 CHECK_INTERFACE(IAudioFlinger, data, reply); 1409 reply->writeInt64(getPrimaryOutputFrameCount()); 1410 return NO_ERROR; 1411 } break; 1412 case SET_LOW_RAM_DEVICE: { 1413 CHECK_INTERFACE(IAudioFlinger, data, reply); 1414 int32_t isLowRamDevice; 1415 int64_t totalMemory; 1416 const status_t status = 1417 data.readInt32(&isLowRamDevice) ?: 1418 data.readInt64(&totalMemory) ?: 1419 setLowRamDevice(isLowRamDevice != 0, totalMemory); 1420 (void)reply->writeInt32(status); 1421 return NO_ERROR; 1422 } break; 1423 case LIST_AUDIO_PORTS: { 1424 CHECK_INTERFACE(IAudioFlinger, data, reply); 1425 unsigned int numPortsReq = data.readInt32(); 1426 if (numPortsReq > MAX_ITEMS_PER_LIST) { 1427 numPortsReq = MAX_ITEMS_PER_LIST; 1428 } 1429 unsigned int numPorts = numPortsReq; 1430 struct audio_port *ports = 1431 (struct audio_port *)calloc(numPortsReq, 1432 sizeof(struct audio_port)); 1433 if (ports == NULL) { 1434 reply->writeInt32(NO_MEMORY); 1435 reply->writeInt32(0); 1436 return NO_ERROR; 1437 } 1438 status_t status = listAudioPorts(&numPorts, ports); 1439 reply->writeInt32(status); 1440 reply->writeInt32(numPorts); 1441 if (status == NO_ERROR) { 1442 if (numPortsReq > numPorts) { 1443 numPortsReq = numPorts; 1444 } 1445 reply->write(ports, numPortsReq * sizeof(struct audio_port)); 1446 } 1447 free(ports); 1448 return NO_ERROR; 1449 } break; 1450 case GET_AUDIO_PORT: { 1451 CHECK_INTERFACE(IAudioFlinger, data, reply); 1452 struct audio_port port = {}; 1453 if (data.read(&port, sizeof(struct audio_port)) != NO_ERROR) { 1454 ALOGE("b/23905951"); 1455 } 1456 status_t status = getAudioPort(&port); 1457 reply->writeInt32(status); 1458 if (status == NO_ERROR) { 1459 reply->write(&port, sizeof(struct audio_port)); 1460 } 1461 return NO_ERROR; 1462 } break; 1463 case CREATE_AUDIO_PATCH: { 1464 CHECK_INTERFACE(IAudioFlinger, data, reply); 1465 struct audio_patch patch; 1466 data.read(&patch, sizeof(struct audio_patch)); 1467 audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE; 1468 if (data.read(&handle, sizeof(audio_patch_handle_t)) != NO_ERROR) { 1469 ALOGE("b/23905951"); 1470 } 1471 status_t status = createAudioPatch(&patch, &handle); 1472 reply->writeInt32(status); 1473 if (status == NO_ERROR) { 1474 reply->write(&handle, sizeof(audio_patch_handle_t)); 1475 } 1476 return NO_ERROR; 1477 } break; 1478 case RELEASE_AUDIO_PATCH: { 1479 CHECK_INTERFACE(IAudioFlinger, data, reply); 1480 audio_patch_handle_t handle; 1481 data.read(&handle, sizeof(audio_patch_handle_t)); 1482 status_t status = releaseAudioPatch(handle); 1483 reply->writeInt32(status); 1484 return NO_ERROR; 1485 } break; 1486 case LIST_AUDIO_PATCHES: { 1487 CHECK_INTERFACE(IAudioFlinger, data, reply); 1488 unsigned int numPatchesReq = data.readInt32(); 1489 if (numPatchesReq > MAX_ITEMS_PER_LIST) { 1490 numPatchesReq = MAX_ITEMS_PER_LIST; 1491 } 1492 unsigned int numPatches = numPatchesReq; 1493 struct audio_patch *patches = 1494 (struct audio_patch *)calloc(numPatchesReq, 1495 sizeof(struct audio_patch)); 1496 if (patches == NULL) { 1497 reply->writeInt32(NO_MEMORY); 1498 reply->writeInt32(0); 1499 return NO_ERROR; 1500 } 1501 status_t status = listAudioPatches(&numPatches, patches); 1502 reply->writeInt32(status); 1503 reply->writeInt32(numPatches); 1504 if (status == NO_ERROR) { 1505 if (numPatchesReq > numPatches) { 1506 numPatchesReq = numPatches; 1507 } 1508 reply->write(patches, numPatchesReq * sizeof(struct audio_patch)); 1509 } 1510 free(patches); 1511 return NO_ERROR; 1512 } break; 1513 case SET_AUDIO_PORT_CONFIG: { 1514 CHECK_INTERFACE(IAudioFlinger, data, reply); 1515 struct audio_port_config config; 1516 data.read(&config, sizeof(struct audio_port_config)); 1517 status_t status = setAudioPortConfig(&config); 1518 reply->writeInt32(status); 1519 return NO_ERROR; 1520 } break; 1521 case GET_AUDIO_HW_SYNC_FOR_SESSION: { 1522 CHECK_INTERFACE(IAudioFlinger, data, reply); 1523 reply->writeInt32(getAudioHwSyncForSession((audio_session_t) data.readInt32())); 1524 return NO_ERROR; 1525 } break; 1526 case SYSTEM_READY: { 1527 CHECK_INTERFACE(IAudioFlinger, data, reply); 1528 systemReady(); 1529 return NO_ERROR; 1530 } break; 1531 case FRAME_COUNT_HAL: { 1532 CHECK_INTERFACE(IAudioFlinger, data, reply); 1533 reply->writeInt64( frameCountHAL((audio_io_handle_t) data.readInt32()) ); 1534 return NO_ERROR; 1535 } break; 1536 case GET_MICROPHONES: { 1537 CHECK_INTERFACE(IAudioFlinger, data, reply); 1538 std::vector<media::MicrophoneInfo> microphones; 1539 status_t status = getMicrophones(µphones); 1540 reply->writeInt32(status); 1541 if (status == NO_ERROR) { 1542 reply->writeParcelableVector(microphones); 1543 } 1544 return NO_ERROR; 1545 } 1546 default: 1547 return BBinder::onTransact(code, data, reply, flags); 1548 } 1549 } 1550 1551 // ---------------------------------------------------------------------------- 1552 1553 } // namespace android 1554
