blob: 1fe3a6943018b45872a46941a985c384a84d52bf [file] [log] [blame]
Mikhail Naganov10548292016-10-31 10:39:47 -07001/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "StreamOutHAL"
Mikhail Naganov685f0e32016-12-16 17:18:08 -080018//#define LOG_NDEBUG 0
Mikhail Naganovb0abafb2017-01-31 17:24:48 -080019#define ATRACE_TAG ATRACE_TAG_AUDIO
Mikhail Naganov10548292016-10-31 10:39:47 -070020
Kevin Rocard67d55082017-03-31 19:34:04 -070021#include <memory>
22
Yifan Hongf9d30342016-11-30 13:45:34 -080023#include <android/log.h>
Mikhail Naganovb29438e2016-12-22 09:21:34 -080024#include <hardware/audio.h>
Mikhail Naganovb0abafb2017-01-31 17:24:48 -080025#include <utils/Trace.h>
Mikhail Naganov10548292016-10-31 10:39:47 -070026
27#include "StreamOut.h"
28
29namespace android {
30namespace hardware {
31namespace audio {
32namespace V2_0 {
33namespace implementation {
34
Mikhail Naganova1db22a2017-02-07 10:49:18 -080035using ::android::hardware::audio::common::V2_0::ThreadInfo;
36
Mikhail Naganovb29438e2016-12-22 09:21:34 -080037namespace {
38
39class WriteThread : public Thread {
40 public:
41 // WriteThread's lifespan never exceeds StreamOut's lifespan.
42 WriteThread(std::atomic<bool>* stop,
43 audio_stream_out_t* stream,
Mikhail Naganova468fa82017-01-31 13:56:02 -080044 StreamOut::CommandMQ* commandMQ,
Mikhail Naganovb29438e2016-12-22 09:21:34 -080045 StreamOut::DataMQ* dataMQ,
46 StreamOut::StatusMQ* statusMQ,
Mikhail Naganova1db22a2017-02-07 10:49:18 -080047 EventFlag* efGroup)
Mikhail Naganovb29438e2016-12-22 09:21:34 -080048 : Thread(false /*canCallJava*/),
49 mStop(stop),
50 mStream(stream),
Mikhail Naganova468fa82017-01-31 13:56:02 -080051 mCommandMQ(commandMQ),
Mikhail Naganovb29438e2016-12-22 09:21:34 -080052 mDataMQ(dataMQ),
53 mStatusMQ(statusMQ),
54 mEfGroup(efGroup),
Kevin Rocard67d55082017-03-31 19:34:04 -070055 mBuffer(nullptr) {
56 }
57 bool init() {
58 mBuffer.reset(new(std::nothrow) uint8_t[mDataMQ->getQuantumCount()]);
59 return mBuffer != nullptr;
Mikhail Naganovb29438e2016-12-22 09:21:34 -080060 }
61 virtual ~WriteThread() {}
62
Mikhail Naganovb29438e2016-12-22 09:21:34 -080063 private:
64 std::atomic<bool>* mStop;
65 audio_stream_out_t* mStream;
Mikhail Naganova468fa82017-01-31 13:56:02 -080066 StreamOut::CommandMQ* mCommandMQ;
Mikhail Naganovb29438e2016-12-22 09:21:34 -080067 StreamOut::DataMQ* mDataMQ;
68 StreamOut::StatusMQ* mStatusMQ;
69 EventFlag* mEfGroup;
Mikhail Naganovb29438e2016-12-22 09:21:34 -080070 std::unique_ptr<uint8_t[]> mBuffer;
Mikhail Naganova468fa82017-01-31 13:56:02 -080071 IStreamOut::WriteStatus mStatus;
Mikhail Naganovb29438e2016-12-22 09:21:34 -080072
73 bool threadLoop() override;
Mikhail Naganova468fa82017-01-31 13:56:02 -080074
75 void doGetLatency();
76 void doGetPresentationPosition();
77 void doWrite();
Mikhail Naganovb29438e2016-12-22 09:21:34 -080078};
79
Mikhail Naganova468fa82017-01-31 13:56:02 -080080void WriteThread::doWrite() {
81 const size_t availToRead = mDataMQ->availableToRead();
82 mStatus.retval = Result::OK;
83 mStatus.reply.written = 0;
84 if (mDataMQ->read(&mBuffer[0], availToRead)) {
85 ssize_t writeResult = mStream->write(mStream, &mBuffer[0], availToRead);
86 if (writeResult >= 0) {
87 mStatus.reply.written = writeResult;
88 } else {
89 mStatus.retval = Stream::analyzeStatus("write", writeResult);
90 }
91 }
92}
93
94void WriteThread::doGetPresentationPosition() {
95 mStatus.retval = StreamOut::getPresentationPositionImpl(
96 mStream,
97 &mStatus.reply.presentationPosition.frames,
98 &mStatus.reply.presentationPosition.timeStamp);
99}
100
101void WriteThread::doGetLatency() {
102 mStatus.retval = Result::OK;
103 mStatus.reply.latencyMs = mStream->get_latency(mStream);
104}
105
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800106bool WriteThread::threadLoop() {
107 // This implementation doesn't return control back to the Thread until it decides to stop,
108 // as the Thread uses mutexes, and this can lead to priority inversion.
109 while(!std::atomic_load_explicit(mStop, std::memory_order_acquire)) {
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800110 uint32_t efState = 0;
Mikhail Naganove8674562017-02-10 08:37:19 -0800111 mEfGroup->wait(static_cast<uint32_t>(MessageQueueFlagBits::NOT_EMPTY), &efState);
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800112 if (!(efState & static_cast<uint32_t>(MessageQueueFlagBits::NOT_EMPTY))) {
113 continue; // Nothing to do.
114 }
Mikhail Naganova468fa82017-01-31 13:56:02 -0800115 if (!mCommandMQ->read(&mStatus.replyTo)) {
116 continue; // Nothing to do.
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800117 }
Mikhail Naganova468fa82017-01-31 13:56:02 -0800118 switch (mStatus.replyTo) {
119 case IStreamOut::WriteCommand::WRITE:
120 doWrite();
121 break;
122 case IStreamOut::WriteCommand::GET_PRESENTATION_POSITION:
123 doGetPresentationPosition();
124 break;
125 case IStreamOut::WriteCommand::GET_LATENCY:
126 doGetLatency();
127 break;
128 default:
129 ALOGE("Unknown write thread command code %d", mStatus.replyTo);
130 mStatus.retval = Result::NOT_SUPPORTED;
131 break;
132 }
133 if (!mStatusMQ->write(&mStatus)) {
134 ALOGE("status message queue write failed");
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800135 }
136 mEfGroup->wake(static_cast<uint32_t>(MessageQueueFlagBits::NOT_FULL));
137 }
138
139 return false;
140}
141
142} // namespace
143
Mikhail Naganov936279e2017-03-29 09:31:18 -0700144StreamOut::StreamOut(const sp<Device>& device, audio_stream_out_t* stream)
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800145 : mIsClosed(false), mDevice(device), mStream(stream),
Eric Laurent7deb7da2016-12-15 19:15:45 -0800146 mStreamCommon(new Stream(&stream->common)),
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800147 mStreamMmap(new StreamMmap<audio_stream_out_t>(stream)),
148 mEfGroup(nullptr), mStopWriteThread(false) {
Mikhail Naganov10548292016-10-31 10:39:47 -0700149}
150
151StreamOut::~StreamOut() {
Mikhail Naganovb0abafb2017-01-31 17:24:48 -0800152 ATRACE_CALL();
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800153 close();
Mikhail Naganovb0abafb2017-01-31 17:24:48 -0800154 if (mWriteThread.get()) {
155 ATRACE_NAME("mWriteThread->join");
156 status_t status = mWriteThread->join();
157 ALOGE_IF(status, "write thread exit error: %s", strerror(-status));
158 }
159 if (mEfGroup) {
160 status_t status = EventFlag::deleteEventFlag(&mEfGroup);
161 ALOGE_IF(status, "write MQ event flag deletion error: %s", strerror(-status));
162 }
163 mCallback.clear();
Mikhail Naganov936279e2017-03-29 09:31:18 -0700164 mDevice->closeOutputStream(mStream);
Mikhail Naganov10548292016-10-31 10:39:47 -0700165 mStream = nullptr;
Mikhail Naganov10548292016-10-31 10:39:47 -0700166}
167
168// Methods from ::android::hardware::audio::V2_0::IStream follow.
169Return<uint64_t> StreamOut::getFrameSize() {
170 return audio_stream_out_frame_size(mStream);
171}
172
173Return<uint64_t> StreamOut::getFrameCount() {
174 return mStreamCommon->getFrameCount();
175}
176
177Return<uint64_t> StreamOut::getBufferSize() {
178 return mStreamCommon->getBufferSize();
179}
180
181Return<uint32_t> StreamOut::getSampleRate() {
182 return mStreamCommon->getSampleRate();
183}
184
185Return<void> StreamOut::getSupportedSampleRates(getSupportedSampleRates_cb _hidl_cb) {
186 return mStreamCommon->getSupportedSampleRates(_hidl_cb);
187}
188
189Return<Result> StreamOut::setSampleRate(uint32_t sampleRateHz) {
190 return mStreamCommon->setSampleRate(sampleRateHz);
191}
192
193Return<AudioChannelMask> StreamOut::getChannelMask() {
194 return mStreamCommon->getChannelMask();
195}
196
197Return<void> StreamOut::getSupportedChannelMasks(getSupportedChannelMasks_cb _hidl_cb) {
198 return mStreamCommon->getSupportedChannelMasks(_hidl_cb);
199}
200
201Return<Result> StreamOut::setChannelMask(AudioChannelMask mask) {
202 return mStreamCommon->setChannelMask(mask);
203}
204
205Return<AudioFormat> StreamOut::getFormat() {
206 return mStreamCommon->getFormat();
207}
208
209Return<void> StreamOut::getSupportedFormats(getSupportedFormats_cb _hidl_cb) {
210 return mStreamCommon->getSupportedFormats(_hidl_cb);
211}
212
213Return<Result> StreamOut::setFormat(AudioFormat format) {
214 return mStreamCommon->setFormat(format);
215}
216
217Return<void> StreamOut::getAudioProperties(getAudioProperties_cb _hidl_cb) {
218 return mStreamCommon->getAudioProperties(_hidl_cb);
219}
220
221Return<Result> StreamOut::addEffect(uint64_t effectId) {
222 return mStreamCommon->addEffect(effectId);
223}
224
225Return<Result> StreamOut::removeEffect(uint64_t effectId) {
226 return mStreamCommon->removeEffect(effectId);
227}
228
229Return<Result> StreamOut::standby() {
230 return mStreamCommon->standby();
231}
232
233Return<AudioDevice> StreamOut::getDevice() {
234 return mStreamCommon->getDevice();
235}
236
237Return<Result> StreamOut::setDevice(const DeviceAddress& address) {
238 return mStreamCommon->setDevice(address);
239}
240
241Return<Result> StreamOut::setConnectedState(const DeviceAddress& address, bool connected) {
242 return mStreamCommon->setConnectedState(address, connected);
243}
244
245Return<Result> StreamOut::setHwAvSync(uint32_t hwAvSync) {
246 return mStreamCommon->setHwAvSync(hwAvSync);
247}
248
249Return<void> StreamOut::getParameters(
250 const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb) {
251 return mStreamCommon->getParameters(keys, _hidl_cb);
252}
253
254Return<Result> StreamOut::setParameters(const hidl_vec<ParameterValue>& parameters) {
255 return mStreamCommon->setParameters(parameters);
256}
257
Martijn Coenen70b9a152016-11-18 15:29:32 +0100258Return<void> StreamOut::debugDump(const hidl_handle& fd) {
Mikhail Naganov10548292016-10-31 10:39:47 -0700259 return mStreamCommon->debugDump(fd);
260}
261
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800262Return<Result> StreamOut::close() {
263 if (mIsClosed) return Result::INVALID_STATE;
264 mIsClosed = true;
265 if (mWriteThread.get()) {
266 mStopWriteThread.store(true, std::memory_order_release);
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800267 }
268 if (mEfGroup) {
Mikhail Naganovb0abafb2017-01-31 17:24:48 -0800269 mEfGroup->wake(static_cast<uint32_t>(MessageQueueFlagBits::NOT_EMPTY));
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800270 }
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800271 return Result::OK;
272}
273
Mikhail Naganov10548292016-10-31 10:39:47 -0700274// Methods from ::android::hardware::audio::V2_0::IStreamOut follow.
275Return<uint32_t> StreamOut::getLatency() {
276 return mStream->get_latency(mStream);
277}
278
279Return<Result> StreamOut::setVolume(float left, float right) {
280 Result retval(Result::NOT_SUPPORTED);
281 if (mStream->set_volume != NULL) {
Eric Laurent7deb7da2016-12-15 19:15:45 -0800282 retval = Stream::analyzeStatus(
Mikhail Naganov10548292016-10-31 10:39:47 -0700283 "set_volume", mStream->set_volume(mStream, left, right));
284 }
285 return retval;
286}
287
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800288Return<void> StreamOut::prepareForWriting(
Mikhail Naganova1db22a2017-02-07 10:49:18 -0800289 uint32_t frameSize, uint32_t framesCount, prepareForWriting_cb _hidl_cb) {
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800290 status_t status;
Mikhail Naganova1db22a2017-02-07 10:49:18 -0800291 ThreadInfo threadInfo = { 0, 0 };
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800292 // Create message queues.
293 if (mDataMQ) {
294 ALOGE("the client attempts to call prepareForWriting twice");
295 _hidl_cb(Result::INVALID_STATE,
Mikhail Naganova1db22a2017-02-07 10:49:18 -0800296 CommandMQ::Descriptor(), DataMQ::Descriptor(), StatusMQ::Descriptor(), threadInfo);
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800297 return Void();
Mikhail Naganov10548292016-10-31 10:39:47 -0700298 }
Mikhail Naganova468fa82017-01-31 13:56:02 -0800299 std::unique_ptr<CommandMQ> tempCommandMQ(new CommandMQ(1));
Kevin Rocardb6498cb2017-03-31 19:36:29 -0700300
301 if (frameSize > std::numeric_limits<size_t>::max() / framesCount) {
302 ALOGE("Requested buffer is too big, %d*%d can not fit in size_t", frameSize, framesCount);
303 _hidl_cb(Result::INVALID_ARGUMENTS,
304 CommandMQ::Descriptor(), DataMQ::Descriptor(), StatusMQ::Descriptor(), threadInfo);
305 return Void();
306 }
307 std::unique_ptr<DataMQ> tempDataMQ(new DataMQ(frameSize * framesCount, true /* EventFlag */));
308
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800309 std::unique_ptr<StatusMQ> tempStatusMQ(new StatusMQ(1));
Mikhail Naganova468fa82017-01-31 13:56:02 -0800310 if (!tempCommandMQ->isValid() || !tempDataMQ->isValid() || !tempStatusMQ->isValid()) {
311 ALOGE_IF(!tempCommandMQ->isValid(), "command MQ is invalid");
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800312 ALOGE_IF(!tempDataMQ->isValid(), "data MQ is invalid");
313 ALOGE_IF(!tempStatusMQ->isValid(), "status MQ is invalid");
314 _hidl_cb(Result::INVALID_ARGUMENTS,
Mikhail Naganova1db22a2017-02-07 10:49:18 -0800315 CommandMQ::Descriptor(), DataMQ::Descriptor(), StatusMQ::Descriptor(), threadInfo);
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800316 return Void();
317 }
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800318 status = EventFlag::createEventFlag(tempDataMQ->getEventFlagWord(), &mEfGroup);
319 if (status != OK || !mEfGroup) {
320 ALOGE("failed creating event flag for data MQ: %s", strerror(-status));
321 _hidl_cb(Result::INVALID_ARGUMENTS,
Mikhail Naganova1db22a2017-02-07 10:49:18 -0800322 CommandMQ::Descriptor(), DataMQ::Descriptor(), StatusMQ::Descriptor(), threadInfo);
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800323 return Void();
324 }
325
326 // Create and launch the thread.
Kevin Rocard67d55082017-03-31 19:34:04 -0700327 auto tempWriteThread = std::make_unique<WriteThread>(
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800328 &mStopWriteThread,
329 mStream,
Mikhail Naganova468fa82017-01-31 13:56:02 -0800330 tempCommandMQ.get(),
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800331 tempDataMQ.get(),
332 tempStatusMQ.get(),
Mikhail Naganova1db22a2017-02-07 10:49:18 -0800333 mEfGroup);
Kevin Rocard67d55082017-03-31 19:34:04 -0700334 if (!tempWriteThread->init()) {
335 _hidl_cb(Result::INVALID_ARGUMENTS,
336 CommandMQ::Descriptor(), DataMQ::Descriptor(), StatusMQ::Descriptor(), threadInfo);
337 return Void();
338 }
339 status = tempWriteThread->run("writer", PRIORITY_URGENT_AUDIO);
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800340 if (status != OK) {
341 ALOGW("failed to start writer thread: %s", strerror(-status));
342 _hidl_cb(Result::INVALID_ARGUMENTS,
Mikhail Naganova1db22a2017-02-07 10:49:18 -0800343 CommandMQ::Descriptor(), DataMQ::Descriptor(), StatusMQ::Descriptor(), threadInfo);
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800344 return Void();
345 }
346
Mikhail Naganova468fa82017-01-31 13:56:02 -0800347 mCommandMQ = std::move(tempCommandMQ);
Mikhail Naganovb29438e2016-12-22 09:21:34 -0800348 mDataMQ = std::move(tempDataMQ);
349 mStatusMQ = std::move(tempStatusMQ);
Kevin Rocard67d55082017-03-31 19:34:04 -0700350 mWriteThread = tempWriteThread.release();
Mikhail Naganova1db22a2017-02-07 10:49:18 -0800351 threadInfo.pid = getpid();
352 threadInfo.tid = mWriteThread->getTid();
353 _hidl_cb(Result::OK,
354 *mCommandMQ->getDesc(), *mDataMQ->getDesc(), *mStatusMQ->getDesc(),
355 threadInfo);
Mikhail Naganov10548292016-10-31 10:39:47 -0700356 return Void();
357}
358
359Return<void> StreamOut::getRenderPosition(getRenderPosition_cb _hidl_cb) {
360 uint32_t halDspFrames;
Eric Laurent7deb7da2016-12-15 19:15:45 -0800361 Result retval = Stream::analyzeStatus(
Mikhail Naganov10548292016-10-31 10:39:47 -0700362 "get_render_position", mStream->get_render_position(mStream, &halDspFrames));
363 _hidl_cb(retval, halDspFrames);
364 return Void();
365}
366
367Return<void> StreamOut::getNextWriteTimestamp(getNextWriteTimestamp_cb _hidl_cb) {
368 Result retval(Result::NOT_SUPPORTED);
369 int64_t timestampUs = 0;
370 if (mStream->get_next_write_timestamp != NULL) {
Eric Laurent7deb7da2016-12-15 19:15:45 -0800371 retval = Stream::analyzeStatus(
Mikhail Naganov10548292016-10-31 10:39:47 -0700372 "get_next_write_timestamp",
373 mStream->get_next_write_timestamp(mStream, &timestampUs));
374 }
375 _hidl_cb(retval, timestampUs);
376 return Void();
377}
378
379Return<Result> StreamOut::setCallback(const sp<IStreamOutCallback>& callback) {
380 if (mStream->set_callback == NULL) return Result::NOT_SUPPORTED;
381 int result = mStream->set_callback(mStream, StreamOut::asyncCallback, this);
382 if (result == 0) {
383 mCallback = callback;
384 }
Eric Laurent7deb7da2016-12-15 19:15:45 -0800385 return Stream::analyzeStatus("set_callback", result);
Mikhail Naganov10548292016-10-31 10:39:47 -0700386}
387
Mikhail Naganov6e81e9b2016-11-16 16:30:17 -0800388Return<Result> StreamOut::clearCallback() {
389 if (mStream->set_callback == NULL) return Result::NOT_SUPPORTED;
390 mCallback.clear();
391 return Result::OK;
392}
393
Mikhail Naganov10548292016-10-31 10:39:47 -0700394// static
395int StreamOut::asyncCallback(stream_callback_event_t event, void*, void *cookie) {
396 wp<StreamOut> weakSelf(reinterpret_cast<StreamOut*>(cookie));
397 sp<StreamOut> self = weakSelf.promote();
Mikhail Naganov6e81e9b2016-11-16 16:30:17 -0800398 if (self == nullptr || self->mCallback == nullptr) return 0;
Mikhail Naganov10548292016-10-31 10:39:47 -0700399 ALOGV("asyncCallback() event %d", event);
400 switch (event) {
401 case STREAM_CBK_EVENT_WRITE_READY:
Mikhail Naganov6e81e9b2016-11-16 16:30:17 -0800402 self->mCallback->onWriteReady();
Mikhail Naganov10548292016-10-31 10:39:47 -0700403 break;
404 case STREAM_CBK_EVENT_DRAIN_READY:
Mikhail Naganov6e81e9b2016-11-16 16:30:17 -0800405 self->mCallback->onDrainReady();
Mikhail Naganov10548292016-10-31 10:39:47 -0700406 break;
407 case STREAM_CBK_EVENT_ERROR:
Mikhail Naganov6e81e9b2016-11-16 16:30:17 -0800408 self->mCallback->onError();
Mikhail Naganov10548292016-10-31 10:39:47 -0700409 break;
410 default:
411 ALOGW("asyncCallback() unknown event %d", event);
412 break;
413 }
414 return 0;
415}
416
417Return<void> StreamOut::supportsPauseAndResume(supportsPauseAndResume_cb _hidl_cb) {
418 _hidl_cb(mStream->pause != NULL, mStream->resume != NULL);
419 return Void();
420}
421
422Return<Result> StreamOut::pause() {
423 return mStream->pause != NULL ?
Eric Laurent7deb7da2016-12-15 19:15:45 -0800424 Stream::analyzeStatus("pause", mStream->pause(mStream)) :
Mikhail Naganov10548292016-10-31 10:39:47 -0700425 Result::NOT_SUPPORTED;
426}
427
428Return<Result> StreamOut::resume() {
429 return mStream->resume != NULL ?
Eric Laurent7deb7da2016-12-15 19:15:45 -0800430 Stream::analyzeStatus("resume", mStream->resume(mStream)) :
Mikhail Naganov10548292016-10-31 10:39:47 -0700431 Result::NOT_SUPPORTED;
432}
433
434Return<bool> StreamOut::supportsDrain() {
435 return mStream->drain != NULL;
436}
437
438Return<Result> StreamOut::drain(AudioDrain type) {
439 return mStream->drain != NULL ?
Eric Laurent7deb7da2016-12-15 19:15:45 -0800440 Stream::analyzeStatus(
Mikhail Naganov10548292016-10-31 10:39:47 -0700441 "drain", mStream->drain(mStream, static_cast<audio_drain_type_t>(type))) :
442 Result::NOT_SUPPORTED;
443}
444
445Return<Result> StreamOut::flush() {
446 return mStream->flush != NULL ?
Eric Laurent7deb7da2016-12-15 19:15:45 -0800447 Stream::analyzeStatus("flush", mStream->flush(mStream)) :
Mikhail Naganov10548292016-10-31 10:39:47 -0700448 Result::NOT_SUPPORTED;
449}
450
Mikhail Naganovee901e32017-01-12 09:28:52 -0800451// static
452Result StreamOut::getPresentationPositionImpl(
453 audio_stream_out_t *stream, uint64_t *frames, TimeSpec *timeStamp) {
Mikhail Naganov10548292016-10-31 10:39:47 -0700454 Result retval(Result::NOT_SUPPORTED);
Mikhail Naganovee901e32017-01-12 09:28:52 -0800455 if (stream->get_presentation_position == NULL) return retval;
456 struct timespec halTimeStamp;
457 retval = Stream::analyzeStatus(
458 "get_presentation_position",
459 stream->get_presentation_position(stream, frames, &halTimeStamp),
460 // Don't logspam on EINVAL--it's normal for get_presentation_position
Mikhail Naganovd63e7902017-01-30 17:05:01 -0800461 // to return it sometimes. EAGAIN may be returned by A2DP audio HAL
462 // implementation.
463 EINVAL, EAGAIN);
Mikhail Naganovee901e32017-01-12 09:28:52 -0800464 if (retval == Result::OK) {
465 timeStamp->tvSec = halTimeStamp.tv_sec;
466 timeStamp->tvNSec = halTimeStamp.tv_nsec;
467 }
468 return retval;
469}
470
471Return<void> StreamOut::getPresentationPosition(getPresentationPosition_cb _hidl_cb) {
Mikhail Naganov10548292016-10-31 10:39:47 -0700472 uint64_t frames = 0;
473 TimeSpec timeStamp = { 0, 0 };
Mikhail Naganovee901e32017-01-12 09:28:52 -0800474 Result retval = getPresentationPositionImpl(mStream, &frames, &timeStamp);
Mikhail Naganov10548292016-10-31 10:39:47 -0700475 _hidl_cb(retval, frames, timeStamp);
476 return Void();
477}
478
Eric Laurent7deb7da2016-12-15 19:15:45 -0800479Return<Result> StreamOut::start() {
480 return mStreamMmap->start();
481}
482
483Return<Result> StreamOut::stop() {
484 return mStreamMmap->stop();
485}
486
487Return<void> StreamOut::createMmapBuffer(int32_t minSizeFrames, createMmapBuffer_cb _hidl_cb) {
488 return mStreamMmap->createMmapBuffer(
489 minSizeFrames, audio_stream_out_frame_size(mStream), _hidl_cb);
490}
491
492Return<void> StreamOut::getMmapPosition(getMmapPosition_cb _hidl_cb) {
493 return mStreamMmap->getMmapPosition(_hidl_cb);
494}
495
Mikhail Naganov10548292016-10-31 10:39:47 -0700496} // namespace implementation
497} // namespace V2_0
498} // namespace audio
499} // namespace hardware
500} // namespace android