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