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