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