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