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