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