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