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