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