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