1 // Copyright (C) 2020 The Android Open Source Project
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include "DummyOutputStream.h"
16
17 namespace audio_proxy {
18 namespace service {
19
DummyOutputStream(const AudioConfig & config)20 DummyOutputStream::DummyOutputStream(const AudioConfig &config)
21 : mChannelMask(config.channelMask), mFormat(config.format),
22 mSampleRate(config.sampleRateHz) {}
23
getBufferSize()24 Return<uint64_t> DummyOutputStream::getBufferSize() { return 0; }
25
getFrameCount()26 Return<uint64_t> DummyOutputStream::getFrameCount() { return 0; }
27
getSupportedSampleRates(AudioFormat,getSupportedSampleRates_cb _hidl_cb)28 Return<void> DummyOutputStream::getSupportedSampleRates(
29 AudioFormat, getSupportedSampleRates_cb _hidl_cb) {
30 _hidl_cb(Result::NOT_SUPPORTED, {});
31 return Void();
32 }
33
getSampleRate()34 Return<uint32_t> DummyOutputStream::getSampleRate() { return mSampleRate; }
35
getSupportedChannelMasks(AudioFormat,getSupportedChannelMasks_cb _hidl_cb)36 Return<void> DummyOutputStream::getSupportedChannelMasks(
37 AudioFormat, getSupportedChannelMasks_cb _hidl_cb) {
38 _hidl_cb(Result::NOT_SUPPORTED, {});
39 return Void();
40 }
41
getChannelMask()42 Return<hidl_bitfield<AudioChannelMask>> DummyOutputStream::getChannelMask() {
43 return mChannelMask;
44 }
45
46 Return<void>
getSupportedFormats(getSupportedFormats_cb _hidl_cb)47 DummyOutputStream::getSupportedFormats(getSupportedFormats_cb _hidl_cb) {
48 _hidl_cb({});
49 return Void();
50 }
51
getFormat()52 Return<AudioFormat> DummyOutputStream::getFormat() { return mFormat; }
53
getLatency()54 Return<uint32_t> DummyOutputStream::getLatency() { return 0; }
55
standby()56 Return<Result> DummyOutputStream::standby() { return Result::NOT_SUPPORTED; }
57
pause()58 Return<Result> DummyOutputStream::pause() { return Result::NOT_SUPPORTED; }
59
resume()60 Return<Result> DummyOutputStream::resume() { return Result::NOT_SUPPORTED; }
61
drain(AudioDrain)62 Return<Result> DummyOutputStream::drain(AudioDrain) {
63 return Result::NOT_SUPPORTED;
64 }
65
66 Return<void>
prepareForWriting(uint32_t frameSize,uint32_t framesCount,prepareForWriting_cb _hidl_cb)67 DummyOutputStream::prepareForWriting(uint32_t frameSize, uint32_t framesCount,
68 prepareForWriting_cb _hidl_cb) {
69 _hidl_cb(Result::NOT_SUPPORTED, {}, {}, {}, {});
70 return Void();
71 }
72
73 Return<Result>
setParameters(const hidl_vec<ParameterValue> & context,const hidl_vec<ParameterValue> & parameters)74 DummyOutputStream::setParameters(const hidl_vec<ParameterValue> &context,
75 const hidl_vec<ParameterValue> ¶meters) {
76 // This method is invoked in AudioFlinger::PlaybackThread::preExit which logs
77 // an error when the returned result is not OK.
78 return Result::OK;
79 }
80
81 Return<void>
getParameters(const hidl_vec<ParameterValue> & context,const hidl_vec<hidl_string> & keys,getParameters_cb _hidl_cb)82 DummyOutputStream::getParameters(const hidl_vec<ParameterValue> &context,
83 const hidl_vec<hidl_string> &keys,
84 getParameters_cb _hidl_cb) {
85 _hidl_cb(Result::NOT_SUPPORTED, {});
86 return Void();
87 }
88
getFrameSize()89 Return<uint64_t> DummyOutputStream::getFrameSize() {
90 // This is a randomly picked value.
91 return 1024;
92 }
93
setSampleRate(uint32_t)94 Return<Result> DummyOutputStream::setSampleRate(uint32_t) {
95 return Result::NOT_SUPPORTED;
96 }
97
98 Return<Result>
setChannelMask(hidl_bitfield<AudioChannelMask>)99 DummyOutputStream::setChannelMask(hidl_bitfield<AudioChannelMask>) {
100 return Result::NOT_SUPPORTED;
101 }
102
setFormat(AudioFormat)103 Return<Result> DummyOutputStream::setFormat(AudioFormat) {
104 return Result::NOT_SUPPORTED;
105 }
106
107 Return<void>
getAudioProperties(getAudioProperties_cb _hidl_cb)108 DummyOutputStream::getAudioProperties(getAudioProperties_cb _hidl_cb) {
109 _hidl_cb(mSampleRate, mChannelMask, mFormat);
110 return Void();
111 }
112
addEffect(uint64_t)113 Return<Result> DummyOutputStream::addEffect(uint64_t) {
114 return Result::NOT_SUPPORTED;
115 }
116
removeEffect(uint64_t)117 Return<Result> DummyOutputStream::removeEffect(uint64_t) {
118 return Result::NOT_SUPPORTED;
119 }
120
getDevices(getDevices_cb _hidl_cb)121 Return<void> DummyOutputStream::getDevices(getDevices_cb _hidl_cb) {
122 _hidl_cb(Result::NOT_SUPPORTED, {});
123 return Void();
124 }
125
setDevices(const hidl_vec<DeviceAddress> &)126 Return<Result> DummyOutputStream::setDevices(const hidl_vec<DeviceAddress> &) {
127 return Result::NOT_SUPPORTED;
128 }
129
setHwAvSync(uint32_t hwAvSync)130 Return<Result> DummyOutputStream::setHwAvSync(uint32_t hwAvSync) {
131 return Result::NOT_SUPPORTED;
132 }
133
start()134 Return<Result> DummyOutputStream::start() { return Result::NOT_SUPPORTED; }
135
stop()136 Return<Result> DummyOutputStream::stop() { return Result::NOT_SUPPORTED; }
137
createMmapBuffer(int32_t minSizeFrames,createMmapBuffer_cb _hidl_cb)138 Return<void> DummyOutputStream::createMmapBuffer(int32_t minSizeFrames,
139 createMmapBuffer_cb _hidl_cb) {
140 _hidl_cb(Result::NOT_SUPPORTED, {});
141 return Void();
142 }
143
getMmapPosition(getMmapPosition_cb _hidl_cb)144 Return<void> DummyOutputStream::getMmapPosition(getMmapPosition_cb _hidl_cb) {
145 _hidl_cb(Result::NOT_SUPPORTED, {});
146 return Void();
147 }
148
close()149 Return<Result> DummyOutputStream::close() { return Result::NOT_SUPPORTED; }
150
setVolume(float left,float right)151 Return<Result> DummyOutputStream::setVolume(float left, float right) {
152 return Result::NOT_SUPPORTED;
153 }
154
updateSourceMetadata(const SourceMetadata &)155 Return<void> DummyOutputStream::updateSourceMetadata(const SourceMetadata &) {
156 return Void();
157 }
158
159 Return<void>
getRenderPosition(getRenderPosition_cb _hidl_cb)160 DummyOutputStream::getRenderPosition(getRenderPosition_cb _hidl_cb) {
161 _hidl_cb(Result::NOT_SUPPORTED, {});
162 return Void();
163 }
164
165 Return<void>
getNextWriteTimestamp(getNextWriteTimestamp_cb _hidl_cb)166 DummyOutputStream::getNextWriteTimestamp(getNextWriteTimestamp_cb _hidl_cb) {
167 _hidl_cb(Result::NOT_SUPPORTED, {});
168 return Void();
169 }
170
setCallback(const sp<IStreamOutCallback> &)171 Return<Result> DummyOutputStream::setCallback(const sp<IStreamOutCallback> &) {
172 return Result::NOT_SUPPORTED;
173 }
174
clearCallback()175 Return<Result> DummyOutputStream::clearCallback() {
176 return Result::NOT_SUPPORTED;
177 }
178
179 Return<void>
supportsPauseAndResume(supportsPauseAndResume_cb _hidl_cb)180 DummyOutputStream::supportsPauseAndResume(supportsPauseAndResume_cb _hidl_cb) {
181 _hidl_cb({}, {});
182 return Void();
183 }
184
supportsDrain()185 Return<bool> DummyOutputStream::supportsDrain() { return false; }
186
flush()187 Return<Result> DummyOutputStream::flush() { return Result::NOT_SUPPORTED; }
188
getPresentationPosition(getPresentationPosition_cb _hidl_cb)189 Return<void> DummyOutputStream::getPresentationPosition(
190 getPresentationPosition_cb _hidl_cb) {
191 _hidl_cb(Result::NOT_SUPPORTED, {}, {});
192 return Void();
193 }
194
selectPresentation(int32_t,int32_t)195 Return<Result> DummyOutputStream::selectPresentation(int32_t, int32_t) {
196 return Result::NOT_SUPPORTED;
197 }
198
199 } // namespace service
200 } // namespace audio_proxy
201