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