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