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