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