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