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