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