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