1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
/*
* Copyright (C) 2020 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.
*/
#pragma once
#include <atomic>
#include <android/hardware/audio/6.0/IStreamOut.h>
#include <android/hardware/audio/6.0/IDevice.h>
#include "stream_common.h"
#include "io_thread.h"
#include "primary_device.h"
namespace android {
namespace hardware {
namespace audio {
namespace V6_0 {
namespace implementation {
using ::android::sp;
using ::android::hardware::hidl_bitfield;
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
using ::android::hardware::Return;
using namespace ::android::hardware::audio::common::V6_0;
using namespace ::android::hardware::audio::V6_0;
struct StreamOut : public IStreamOut {
StreamOut(sp<PrimaryDevice> dev,
int32_t ioHandle,
const DeviceAddress& device,
const AudioConfig& config,
hidl_bitfield<AudioOutputFlag> flags,
const SourceMetadata& sourceMetadata);
~StreamOut();
// IStream
Return<uint64_t> getFrameSize() override;
Return<uint64_t> getFrameCount() override;
Return<uint64_t> getBufferSize() override;
Return<uint32_t> getSampleRate() override;
Return<void> getSupportedSampleRates(AudioFormat format, getSupportedSampleRates_cb _hidl_cb) override;
Return<Result> setSampleRate(uint32_t sampleRateHz) override;
Return<hidl_bitfield<AudioChannelMask>> getChannelMask() override;
Return<void> getSupportedChannelMasks(AudioFormat format, getSupportedChannelMasks_cb _hidl_cb) override;
Return<Result> setChannelMask(hidl_bitfield<AudioChannelMask> mask) override;
Return<AudioFormat> getFormat() override;
Return<void> getSupportedFormats(getSupportedFormats_cb _hidl_cb) override;
Return<Result> setFormat(AudioFormat format) override;
Return<void> getAudioProperties(getAudioProperties_cb _hidl_cb) override;
Return<Result> addEffect(uint64_t effectId) override;
Return<Result> removeEffect(uint64_t effectId) override;
Return<Result> standby() override;
Return<void> getDevices(getDevices_cb _hidl_cb) override;
Return<Result> setDevices(const hidl_vec<DeviceAddress>& devices) override;
Return<Result> setHwAvSync(uint32_t hwAvSync) override;
Return<void> getParameters(const hidl_vec<ParameterValue>& context,
const hidl_vec<hidl_string>& keys,
getParameters_cb _hidl_cb) override;
Return<Result> setParameters(const hidl_vec<ParameterValue>& context,
const hidl_vec<ParameterValue>& parameters) override;
Return<Result> start() override;
Return<Result> stop() override;
Return<void> createMmapBuffer(int32_t minSizeFrames, createMmapBuffer_cb _hidl_cb) override;
Return<void> getMmapPosition(getMmapPosition_cb _hidl_cb) override;
Return<Result> close() override;
// IStreamOut
Return<uint32_t> getLatency() override;
Return<Result> setVolume(float left, float right) override;
Return<void> updateSourceMetadata(const SourceMetadata& sourceMetadata) override;
Return<void> prepareForWriting(uint32_t frameSize, uint32_t framesCount,
prepareForWriting_cb _hidl_cb) override;
Return<void> getRenderPosition(getRenderPosition_cb _hidl_cb) override;
Return<void> getNextWriteTimestamp(getNextWriteTimestamp_cb _hidl_cb) override;
Return<Result> setCallback(const sp<IStreamOutCallback>& callback) override;
Return<Result> clearCallback() override;
Return<Result> setEventCallback(const sp<IStreamOutEventCallback>& callback) override;
Return<void> supportsPauseAndResume(supportsPauseAndResume_cb _hidl_cb) override;
Return<Result> pause() override;
Return<Result> resume() override;
Return<bool> supportsDrain() override;
Return<Result> drain(AudioDrain type) override;
Return<Result> flush() override;
Return<void> getPresentationPosition(getPresentationPosition_cb _hidl_cb) override;
Return<Result> selectPresentation(int32_t presentationId, int32_t programId) override;
Return<void> getDualMonoMode(getDualMonoMode_cb _hidl_cb) override;
Return<Result> setDualMonoMode(DualMonoMode mode) override;
Return<void> getAudioDescriptionMixLevel(getAudioDescriptionMixLevel_cb _hidl_cb) override;
Return<Result> setAudioDescriptionMixLevel(float leveldB) override;
Return<void> getPlaybackRateParameters(getPlaybackRateParameters_cb _hidl_cb) override;
Return<Result> setPlaybackRateParameters(const PlaybackRate &playbackRate) override;
void setMasterVolume(float volume);
float getEffectiveVolume() const { return mEffectiveVolume; }
const DeviceAddress &getDeviceAddress() const { return mCommon.m_device; }
const AudioConfig &getAudioConfig() const { return mCommon.m_config; }
const hidl_bitfield<AudioOutputFlag> &getAudioOutputFlags() const { return mCommon.m_flags; }
uint64_t &getFrameCounter() { return mFrames; }
private:
Result closeImpl(bool fromDctor);
void updateEffectiveVolumeLocked();
sp<PrimaryDevice> mDev;
const StreamCommon mCommon;
const SourceMetadata mSourceMetadata;
std::unique_ptr<IOThread> mWriteThread;
float mMasterVolume = 1.0f; // requires mMutex
float mStreamVolume = 1.0f; // requires mMutex
std::atomic<float> mEffectiveVolume = 1.0f;
std::mutex mMutex;
// The count is not reset to zero when output enters standby.
uint64_t mFrames = 0;
};
} // namespace implementation
} // namespace V6_0
} // namespace audio
} // namespace hardware
} // namespace android
|
