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