1/* //device/include/server/AudioFlinger/AudioFlinger.h 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#ifndef ANDROID_AUDIO_FLINGER_H 19#define ANDROID_AUDIO_FLINGER_H 20 21#include <stdint.h> 22#include <sys/types.h> 23 24#include <media/IAudioFlinger.h> 25#include <media/IAudioFlingerClient.h> 26#include <media/IAudioTrack.h> 27#include <media/IAudioRecord.h> 28#include <media/AudioTrack.h> 29 30#include <utils/Atomic.h> 31#include <utils/Errors.h> 32#include <utils/threads.h> 33#include <utils/MemoryDealer.h> 34#include <utils/KeyedVector.h> 35#include <utils/SortedVector.h> 36#include <utils/Vector.h> 37 38#include <hardware_legacy/AudioHardwareInterface.h> 39 40#include "AudioBufferProvider.h" 41 42namespace android { 43 44class audio_track_cblk_t; 45class AudioMixer; 46class AudioBuffer; 47 48 49// ---------------------------------------------------------------------------- 50 51#define LIKELY( exp ) (__builtin_expect( (exp) != 0, true )) 52#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false )) 53 54 55// ---------------------------------------------------------------------------- 56 57static const nsecs_t kStandbyTimeInNsecs = seconds(3); 58 59class AudioFlinger : public BnAudioFlinger, public IBinder::DeathRecipient 60{ 61public: 62 static void instantiate(); 63 64 virtual status_t dump(int fd, const Vector<String16>& args); 65 66 // IAudioFlinger interface 67 virtual sp<IAudioTrack> createTrack( 68 pid_t pid, 69 int streamType, 70 uint32_t sampleRate, 71 int format, 72 int channelCount, 73 int frameCount, 74 uint32_t flags, 75 const sp<IMemory>& sharedBuffer, 76 status_t *status); 77 78 virtual uint32_t sampleRate(int output) const; 79 virtual int channelCount(int output) const; 80 virtual int format(int output) const; 81 virtual size_t frameCount(int output) const; 82 virtual uint32_t latency(int output) const; 83 84 virtual status_t setMasterVolume(float value); 85 virtual status_t setMasterMute(bool muted); 86 87 virtual float masterVolume() const; 88 virtual bool masterMute() const; 89 90 virtual status_t setStreamVolume(int stream, float value); 91 virtual status_t setStreamMute(int stream, bool muted); 92 93 virtual float streamVolume(int stream) const; 94 virtual bool streamMute(int stream) const; 95 96 virtual status_t setRouting(int mode, uint32_t routes, uint32_t mask); 97 virtual uint32_t getRouting(int mode) const; 98 99 virtual status_t setMode(int mode); 100 virtual int getMode() const; 101 102 virtual status_t setMicMute(bool state); 103 virtual bool getMicMute() const; 104 105 virtual bool isMusicActive() const; 106 107 virtual bool isA2dpEnabled() const; 108 109 virtual status_t setParameter(const char* key, const char* value); 110 111 virtual void registerClient(const sp<IAudioFlingerClient>& client); 112 113 virtual size_t getInputBufferSize(uint32_t sampleRate, int format, int channelCount); 114 115 virtual void wakeUp() { mWaitWorkCV.broadcast(); } 116 117 // IBinder::DeathRecipient 118 virtual void binderDied(const wp<IBinder>& who); 119 120 enum hardware_call_state { 121 AUDIO_HW_IDLE = 0, 122 AUDIO_HW_INIT, 123 AUDIO_HW_OUTPUT_OPEN, 124 AUDIO_HW_OUTPUT_CLOSE, 125 AUDIO_HW_INPUT_OPEN, 126 AUDIO_HW_INPUT_CLOSE, 127 AUDIO_HW_STANDBY, 128 AUDIO_HW_SET_MASTER_VOLUME, 129 AUDIO_HW_GET_ROUTING, 130 AUDIO_HW_SET_ROUTING, 131 AUDIO_HW_GET_MODE, 132 AUDIO_HW_SET_MODE, 133 AUDIO_HW_GET_MIC_MUTE, 134 AUDIO_HW_SET_MIC_MUTE, 135 AUDIO_SET_VOICE_VOLUME, 136 AUDIO_SET_PARAMETER, 137 }; 138 139 // record interface 140 virtual sp<IAudioRecord> openRecord( 141 pid_t pid, 142 int inputSource, 143 uint32_t sampleRate, 144 int format, 145 int channelCount, 146 int frameCount, 147 uint32_t flags, 148 status_t *status); 149 150 virtual status_t onTransact( 151 uint32_t code, 152 const Parcel& data, 153 Parcel* reply, 154 uint32_t flags); 155 156private: 157 AudioFlinger(); 158 virtual ~AudioFlinger(); 159 160 void setOutput(int outputType); 161 void doSetOutput(int outputType); 162 163#ifdef WITH_A2DP 164 void setA2dpEnabled_l(bool enable); 165 void checkA2dpEnabledChange_l(); 166#endif 167 static bool streamForcedToSpeaker(int streamType); 168 169 // Management of forced route to speaker for certain track types. 170 enum force_speaker_command { 171 ACTIVE_TRACK_ADDED = 0, 172 ACTIVE_TRACK_REMOVED, 173 CHECK_ROUTE_RESTORE_TIME, 174 FORCE_ROUTE_RESTORE 175 }; 176 void handleForcedSpeakerRoute(int command); 177#ifdef WITH_A2DP 178 void handleRouteDisablesA2dp_l(int routes); 179#endif 180 181 // Internal dump utilites. 182 status_t dumpPermissionDenial(int fd, const Vector<String16>& args); 183 status_t dumpClients(int fd, const Vector<String16>& args); 184 status_t dumpInternals(int fd, const Vector<String16>& args); 185 186 // --- Client --- 187 class Client : public RefBase { 188 public: 189 Client(const sp<AudioFlinger>& audioFlinger, pid_t pid); 190 virtual ~Client(); 191 const sp<MemoryDealer>& heap() const; 192 pid_t pid() const { return mPid; } 193 private: 194 Client(const Client&); 195 Client& operator = (const Client&); 196 sp<AudioFlinger> mAudioFlinger; 197 sp<MemoryDealer> mMemoryDealer; 198 pid_t mPid; 199 }; 200 201 202 class TrackHandle; 203 class RecordHandle; 204 class AudioRecordThread; 205 206 207 // --- MixerThread --- 208 class MixerThread : public Thread { 209 public: 210 211 // --- Track --- 212 213 // base for record and playback 214 class TrackBase : public AudioBufferProvider, public RefBase { 215 216 public: 217 enum track_state { 218 IDLE, 219 TERMINATED, 220 STOPPED, 221 RESUMING, 222 ACTIVE, 223 PAUSING, 224 PAUSED 225 }; 226 227 enum track_flags { 228 STEPSERVER_FAILED = 0x01, // StepServer could not acquire cblk->lock mutex 229 SYSTEM_FLAGS_MASK = 0x0000ffffUL, 230 // The upper 16 bits are used for track-specific flags. 231 }; 232 233 TrackBase(const sp<MixerThread>& mixerThread, 234 const sp<Client>& client, 235 uint32_t sampleRate, 236 int format, 237 int channelCount, 238 int frameCount, 239 uint32_t flags, 240 const sp<IMemory>& sharedBuffer); 241 ~TrackBase(); 242 243 virtual status_t start() = 0; 244 virtual void stop() = 0; 245 sp<IMemory> getCblk() const; 246 247 protected: 248 friend class MixerThread; 249 friend class RecordHandle; 250 friend class AudioRecordThread; 251 252 TrackBase(const TrackBase&); 253 TrackBase& operator = (const TrackBase&); 254 255 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) = 0; 256 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); 257 258 audio_track_cblk_t* cblk() const { 259 return mCblk; 260 } 261 262 int format() const { 263 return mFormat; 264 } 265 266 int channelCount() const ; 267 268 int sampleRate() const; 269 270 void* getBuffer(uint32_t offset, uint32_t frames) const; 271 272 int name() const { 273 return mName; 274 } 275 276 bool isStopped() const { 277 return mState == STOPPED; 278 } 279 280 bool isTerminated() const { 281 return mState == TERMINATED; 282 } 283 284 bool step(); 285 void reset(); 286 287 sp<MixerThread> mMixerThread; 288 sp<Client> mClient; 289 sp<IMemory> mCblkMemory; 290 audio_track_cblk_t* mCblk; 291 void* mBuffer; 292 void* mBufferEnd; 293 uint32_t mFrameCount; 294 int mName; 295 // we don't really need a lock for these 296 int mState; 297 int mClientTid; 298 uint8_t mFormat; 299 uint32_t mFlags; 300 }; 301 302 // playback track 303 class Track : public TrackBase { 304 public: 305 Track( const sp<MixerThread>& mixerThread, 306 const sp<Client>& client, 307 int streamType, 308 uint32_t sampleRate, 309 int format, 310 int channelCount, 311 int frameCount, 312 const sp<IMemory>& sharedBuffer); 313 ~Track(); 314 315 void dump(char* buffer, size_t size); 316 virtual status_t start(); 317 virtual void stop(); 318 void pause(); 319 320 void flush(); 321 void destroy(); 322 void mute(bool); 323 void setVolume(float left, float right); 324 325 int type() const { 326 return mStreamType; 327 } 328 329 330 protected: 331 friend class MixerThread; 332 friend class AudioFlinger; 333 friend class AudioFlinger::TrackHandle; 334 335 Track(const Track&); 336 Track& operator = (const Track&); 337 338 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer); 339 340 bool isMuted() const { 341 return (mMute || mMixerThread->mStreamTypes[mStreamType].mute); 342 } 343 344 bool isPausing() const { 345 return mState == PAUSING; 346 } 347 348 bool isPaused() const { 349 return mState == PAUSED; 350 } 351 352 bool isReady() const; 353 354 void setPaused() { mState = PAUSED; } 355 void reset(); 356 357 // we don't really need a lock for these 358 float mVolume[2]; 359 volatile bool mMute; 360 // FILLED state is used for suppressing volume ramp at begin of playing 361 enum {FS_FILLING, FS_FILLED, FS_ACTIVE}; 362 mutable uint8_t mFillingUpStatus; 363 int8_t mRetryCount; 364 sp<IMemory> mSharedBuffer; 365 bool mResetDone; 366 int mStreamType; 367 }; // end of Track 368 369 // record track 370 class RecordTrack : public TrackBase { 371 public: 372 RecordTrack(const sp<MixerThread>& mixerThread, 373 const sp<Client>& client, 374 int inputSource, 375 uint32_t sampleRate, 376 int format, 377 int channelCount, 378 int frameCount, 379 uint32_t flags); 380 ~RecordTrack(); 381 382 virtual status_t start(); 383 virtual void stop(); 384 385 bool overflow() { bool tmp = mOverflow; mOverflow = false; return tmp; } 386 bool setOverflow() { bool tmp = mOverflow; mOverflow = true; return tmp; } 387 388 int inputSource() const { return mInputSource; } 389 390 private: 391 friend class AudioFlinger; 392 friend class AudioFlinger::RecordHandle; 393 friend class AudioFlinger::AudioRecordThread; 394 friend class MixerThread; 395 396 RecordTrack(const Track&); 397 RecordTrack& operator = (const Track&); 398 399 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer); 400 401 bool mOverflow; 402 int mInputSource; 403 }; 404 405 // playback track 406 class OutputTrack : public Track { 407 public: 408 409 class Buffer: public AudioBufferProvider::Buffer { 410 public: 411 int16_t *mBuffer; 412 }; 413 414 OutputTrack( const sp<MixerThread>& mixerThread, 415 uint32_t sampleRate, 416 int format, 417 int channelCount, 418 int frameCount); 419 ~OutputTrack(); 420 421 virtual status_t start(); 422 virtual void stop(); 423 void write(int16_t* data, uint32_t frames); 424 bool bufferQueueEmpty() { return (mBufferQueue.size() == 0) ? true : false; } 425 426 private: 427 428 status_t obtainBuffer(AudioBufferProvider::Buffer* buffer); 429 void clearBufferQueue(); 430 431 sp<MixerThread> mOutputMixerThread; 432 Vector < Buffer* > mBufferQueue; 433 AudioBufferProvider::Buffer mOutBuffer; 434 uint32_t mFramesWritten; 435 436 }; // end of OutputTrack 437 438 MixerThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int outputType); 439 virtual ~MixerThread(); 440 441 virtual status_t dump(int fd, const Vector<String16>& args); 442 443 // Thread virtuals 444 virtual bool threadLoop(); 445 virtual status_t readyToRun(); 446 virtual void onFirstRef(); 447 448 virtual uint32_t sampleRate() const; 449 virtual int channelCount() const; 450 virtual int format() const; 451 virtual size_t frameCount() const; 452 virtual uint32_t latency() const; 453 454 virtual status_t setMasterVolume(float value); 455 virtual status_t setMasterMute(bool muted); 456 457 virtual float masterVolume() const; 458 virtual bool masterMute() const; 459 460 virtual status_t setStreamVolume(int stream, float value); 461 virtual status_t setStreamMute(int stream, bool muted); 462 463 virtual float streamVolume(int stream) const; 464 virtual bool streamMute(int stream) const; 465 466 bool isMusicActive_l() const; 467 468 469 sp<Track> createTrack_l( 470 const sp<AudioFlinger::Client>& client, 471 int streamType, 472 uint32_t sampleRate, 473 int format, 474 int channelCount, 475 int frameCount, 476 const sp<IMemory>& sharedBuffer, 477 status_t *status); 478 479 void getTracks_l(SortedVector < sp<Track> >& tracks, 480 SortedVector < wp<Track> >& activeTracks); 481 void putTracks_l(SortedVector < sp<Track> >& tracks, 482 SortedVector < wp<Track> >& activeTracks); 483 void setOuputTrack(OutputTrack *track) { mOutputTrack = track; } 484 485 struct stream_type_t { 486 stream_type_t() 487 : volume(1.0f), 488 mute(false) 489 { 490 } 491 float volume; 492 bool mute; 493 }; 494 495 private: 496 497 498 friend class AudioFlinger; 499 friend class Track; 500 friend class TrackBase; 501 friend class RecordTrack; 502 503 MixerThread(const Client&); 504 MixerThread& operator = (const MixerThread&); 505 506 status_t addTrack_l(const sp<Track>& track); 507 void destroyTrack_l(const sp<Track>& track); 508 int getTrackName_l(); 509 void deleteTrackName_l(int name); 510 void addActiveTrack_l(const wp<Track>& t); 511 void removeActiveTrack_l(const wp<Track>& t); 512 size_t getOutputFrameCount(); 513 514 status_t dumpInternals(int fd, const Vector<String16>& args); 515 status_t dumpTracks(int fd, const Vector<String16>& args); 516 517 sp<AudioFlinger> mAudioFlinger; 518 SortedVector< wp<Track> > mActiveTracks; 519 SortedVector< sp<Track> > mTracks; 520 stream_type_t mStreamTypes[AudioSystem::NUM_STREAM_TYPES]; 521 AudioMixer* mAudioMixer; 522 AudioStreamOut* mOutput; 523 int mOutputType; 524 uint32_t mSampleRate; 525 size_t mFrameCount; 526 int mChannelCount; 527 int mFormat; 528 int16_t* mMixBuffer; 529 float mMasterVolume; 530 bool mMasterMute; 531 nsecs_t mLastWriteTime; 532 int mNumWrites; 533 int mNumDelayedWrites; 534 bool mStandby; 535 bool mInWrite; 536 sp <OutputTrack> mOutputTrack; 537 }; 538 539 540 friend class AudioBuffer; 541 542 class TrackHandle : public android::BnAudioTrack { 543 public: 544 TrackHandle(const sp<MixerThread::Track>& track); 545 virtual ~TrackHandle(); 546 virtual status_t start(); 547 virtual void stop(); 548 virtual void flush(); 549 virtual void mute(bool); 550 virtual void pause(); 551 virtual void setVolume(float left, float right); 552 virtual sp<IMemory> getCblk() const; 553 virtual status_t onTransact( 554 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); 555 private: 556 sp<MixerThread::Track> mTrack; 557 }; 558 559 friend class Client; 560 friend class MixerThread::Track; 561 562 563 void removeClient(pid_t pid); 564 565 566 567 class RecordHandle : public android::BnAudioRecord { 568 public: 569 RecordHandle(const sp<MixerThread::RecordTrack>& recordTrack); 570 virtual ~RecordHandle(); 571 virtual status_t start(); 572 virtual void stop(); 573 virtual sp<IMemory> getCblk() const; 574 virtual status_t onTransact( 575 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); 576 private: 577 sp<MixerThread::RecordTrack> mRecordTrack; 578 }; 579 580 // record thread 581 class AudioRecordThread : public Thread 582 { 583 public: 584 AudioRecordThread(AudioHardwareInterface* audioHardware, const sp<AudioFlinger>& audioFlinger); 585 virtual ~AudioRecordThread(); 586 virtual bool threadLoop(); 587 virtual status_t readyToRun() { return NO_ERROR; } 588 virtual void onFirstRef() {} 589 590 status_t start(MixerThread::RecordTrack* recordTrack); 591 void stop(MixerThread::RecordTrack* recordTrack); 592 void exit(); 593 status_t dump(int fd, const Vector<String16>& args); 594 595 private: 596 AudioRecordThread(); 597 AudioHardwareInterface *mAudioHardware; 598 sp<AudioFlinger> mAudioFlinger; 599 sp<MixerThread::RecordTrack> mRecordTrack; 600 Mutex mLock; 601 Condition mWaitWorkCV; 602 Condition mStopped; 603 volatile bool mActive; 604 status_t mStartStatus; 605 }; 606 607 friend class AudioRecordThread; 608 friend class MixerThread; 609 610 status_t startRecord(MixerThread::RecordTrack* recordTrack); 611 void stopRecord(MixerThread::RecordTrack* recordTrack); 612 613 mutable Mutex mHardwareLock; 614 mutable Mutex mLock; 615 mutable Condition mWaitWorkCV; 616 617 DefaultKeyedVector< pid_t, wp<Client> > mClients; 618 619 sp<MixerThread> mA2dpMixerThread; 620 sp<MixerThread> mHardwareMixerThread; 621 AudioHardwareInterface* mAudioHardware; 622 AudioHardwareInterface* mA2dpAudioInterface; 623 sp<AudioRecordThread> mAudioRecordThread; 624 bool mA2dpEnabled; 625 bool mNotifyA2dpChange; 626 mutable int mHardwareStatus; 627 SortedVector< wp<IBinder> > mNotificationClients; 628 int mForcedSpeakerCount; 629 int mA2dpDisableCount; 630 631 // true if A2DP should resume when mA2dpDisableCount returns to zero 632 bool mA2dpSuppressed; 633 uint32_t mSavedRoute; 634 uint32_t mForcedRoute; 635 nsecs_t mRouteRestoreTime; 636 bool mMusicMuteSaved; 637}; 638 639// ---------------------------------------------------------------------------- 640 641}; // namespace android 642 643#endif // ANDROID_AUDIO_FLINGER_H 644