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