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