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