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