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