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