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