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