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