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