| /* |
| ** |
| ** Copyright 2014, The Android Open Source Project |
| ** |
| ** Licensed under the Apache License, Version 2.0 (the "License"); |
| ** you may not use this file except in compliance with the License. |
| ** You may obtain a copy of the License at |
| ** |
| ** http://www.apache.org/licenses/LICENSE-2.0 |
| ** |
| ** Unless required by applicable law or agreed to in writing, software |
| ** distributed under the License is distributed on an "AS IS" BASIS, |
| ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| ** See the License for the specific language governing permissions and |
| ** limitations under the License. |
| */ |
| |
| #ifndef ANDROID_AUDIO_HARDWARE_OUTPUT_H |
| #define ANDROID_AUDIO_HARDWARE_OUTPUT_H |
| |
| #include <stdint.h> |
| #include <sys/types.h> |
| |
| #include <hardware/audio.h> |
| #include <utils/String8.h> |
| #include <utils/threads.h> |
| |
| #include "alsa_utils.h" |
| #include "AudioOutput.h" |
| |
| namespace android { |
| |
| class AudioStreamOut; |
| class AudioOutput; |
| |
| class AudioHardwareOutput { |
| public: |
| AudioHardwareOutput(); |
| virtual ~AudioHardwareOutput(); |
| status_t initCheck(); |
| status_t setMasterVolume(float volume); |
| status_t getMasterVolume(float* volume); |
| status_t setMasterMute(bool mute); |
| status_t getMasterMute(bool* mute); |
| status_t setParameters(const char* kvpairs); |
| char* getParameters(const char* keys); |
| status_t dump(int fd); |
| void updateRouting(uint32_t devMask); |
| uint32_t getMaxDelayCompUsec() const { return mMaxDelayCompUsec; } |
| uint32_t getVideoDelayCompUsec() const { |
| return mSettings.videoDelayCompUsec; |
| } |
| HDMIAudioCaps& getHDMIAudioCaps() { return mHDMIAudioCaps; } |
| |
| // Interface to allow streams to obtain and release various physical |
| // outputs. |
| status_t obtainOutput(const AudioStreamOut& tgtStream, |
| uint32_t devMask, |
| sp<AudioOutput>* newOutput); |
| void releaseOutput(const AudioStreamOut& tgtStream, |
| const sp<AudioOutput>& releaseMe); |
| |
| |
| // create I/O streams |
| AudioStreamOut* openOutputStream(uint32_t devices, |
| audio_format_t *format, |
| uint32_t *channels, |
| uint32_t *sampleRate, |
| audio_output_flags_t flags, |
| status_t *status); |
| void closeOutputStream(AudioStreamOut* out); |
| |
| void standbyStatusUpdate(bool isInStandby, bool isMCStream); |
| |
| private: |
| struct OutputSettings { |
| bool allowed; |
| uint32_t delayCompUsec; |
| bool isFixed; |
| float fixedLvl; |
| void setDefaults(); |
| }; |
| |
| struct Settings { |
| OutputSettings hdmi; |
| uint32_t videoDelayCompUsec; |
| float masterVolume; |
| bool masterMute; |
| void setDefaults(); |
| }; |
| |
| void updateTgtDevices_l(); |
| bool applyOutputSettings_l(const OutputSettings& initial, |
| const OutputSettings& current, |
| OutputSettings& updateMe, |
| uint32_t outDevMask); |
| |
| // Notes on locking: |
| // There are 3 locks in the AudioHardware class; mStreamLock, mOutputLock |
| // and mSettingsLock. |
| // |
| // mStreamLock is held when interacting with AudioStreamOuts, in particular |
| // during creation and destruction of streams, and during routing changes |
| // (HDMI connecting and disconnecting) which (potentially) end up effecting |
| // the target device masks of the output streams. |
| // |
| // mOutputLock is held while interacting with AudioOutputs (which represent |
| // the physical outputs of the system). AudioStreamOuts grab this lock |
| // during calls to (obtain|release)Output which can trigger instantiation |
| // and destruction of AudioOutputs. During this operation, the |
| // AudioStreamOut instance will be holding its own "routing" lock. Care |
| // should be taken to never hold the output lock or setting lock while making |
| // a call into an AudioStreamOut which may obtain the routing lock. |
| // Currently, the set of publicly accessible calls in AudioStreamOut which |
| // may obtain the routing lock are... |
| // 1) ~AudioStreamOut (calls releaseAllOutputs) |
| // 2) standby (calls releaseAllOutputs) |
| // 3) pause (calls releaseAllOutputs) |
| // 4) setTgtDevices |
| // 5) getPresentationPosition |
| // 6) write |
| // |
| // mSettingsLock is held while reading settings and while writing/applying |
| // settings to existing outputs. Lock ordering is important when applying |
| // settings to outputs as the both the output and settings lock need to be |
| // held at the same time. Whenever settings need to be applied to outputs, |
| // the output lock should always obtained first, followed by the settings |
| // lock. |
| |
| Mutex mStreamLock; |
| AudioStreamOut *mMainOutput; |
| AudioStreamOut *mMCOutput; |
| bool mHDMIConnected; |
| |
| Mutex mOutputLock; |
| AudioOutputList mPhysOutputs; |
| |
| Mutex mSettingsLock; |
| Settings mSettings; |
| uint32_t mMaxDelayCompUsec; |
| |
| HDMIAudioCaps mHDMIAudioCaps; |
| int mHDMICardID; |
| |
| static const String8 kHDMIAllowedParamKey; |
| static const String8 kHDMIDelayCompParamKey; |
| static const String8 kFixedHDMIOutputParamKey; |
| static const String8 kFixedHDMIOutputLevelParamKey; |
| static const String8 kVideoDelayCompParamKey; |
| static const float kDefaultMasterVol; |
| |
| }; |
| |
| // ---------------------------------------------------------------------------- |
| |
| }; // namespace android |
| |
| #endif // ANDROID_AUDIO_HARDWARE_OUTPUT_H |