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