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