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