Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2010 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_NDEBUG 0 |
| 18 | #define LOG_TAG "NuPlayerRenderer" |
| 19 | #include <utils/Log.h> |
| 20 | |
| 21 | #include "NuPlayerRenderer.h" |
Andy Hung | a0b3971 | 2015-05-31 22:40:49 -0700 | [diff] [blame] | 22 | #include <cutils/properties.h> |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 23 | #include <media/stagefright/foundation/ABuffer.h> |
| 24 | #include <media/stagefright/foundation/ADebug.h> |
Andreas Huber | 5bc087c | 2010-12-23 10:27:40 -0800 | [diff] [blame] | 25 | #include <media/stagefright/foundation/AMessage.h> |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 26 | #include <media/stagefright/foundation/AUtils.h> |
Weiyin Jiang | 35d5af1 | 2015-01-28 16:14:02 +0800 | [diff] [blame] | 27 | #include <media/stagefright/foundation/AWakeLock.h> |
Wei Jia | 5833b6a | 2015-03-09 17:01:47 -0700 | [diff] [blame] | 28 | #include <media/stagefright/MediaClock.h> |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 29 | #include <media/stagefright/MediaErrors.h> |
| 30 | #include <media/stagefright/MetaData.h> |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 31 | #include <media/stagefright/Utils.h> |
Lajos Molnar | a3725d7 | 2015-07-01 16:47:22 -0700 | [diff] [blame] | 32 | #include <media/stagefright/VideoFrameScheduler.h> |
Lajos Molnar | dc43dfa | 2014-05-07 15:33:04 -0700 | [diff] [blame] | 33 | |
Lajos Molnar | 0952483 | 2014-07-17 14:29:51 -0700 | [diff] [blame] | 34 | #include <inttypes.h> |
| 35 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 36 | namespace android { |
| 37 | |
Andy Hung | a0b3971 | 2015-05-31 22:40:49 -0700 | [diff] [blame] | 38 | /* |
| 39 | * Example of common configuration settings in shell script form |
| 40 | |
| 41 | #Turn offload audio off (use PCM for Play Music) -- AudioPolicyManager |
| 42 | adb shell setprop audio.offload.disable 1 |
| 43 | |
| 44 | #Allow offload audio with video (requires offloading to be enabled) -- AudioPolicyManager |
| 45 | adb shell setprop audio.offload.video 1 |
| 46 | |
| 47 | #Use audio callbacks for PCM data |
| 48 | adb shell setprop media.stagefright.audio.cbk 1 |
| 49 | |
Andy Hung | 288da02 | 2015-05-31 22:55:59 -0700 | [diff] [blame] | 50 | #Use deep buffer for PCM data with video (it is generally enabled for audio-only) |
| 51 | adb shell setprop media.stagefright.audio.deep 1 |
| 52 | |
Andy Hung | 179652e | 2015-05-31 22:49:46 -0700 | [diff] [blame] | 53 | #Set size of buffers for pcm audio sink in msec (example: 1000 msec) |
| 54 | adb shell setprop media.stagefright.audio.sink 1000 |
| 55 | |
Andy Hung | a0b3971 | 2015-05-31 22:40:49 -0700 | [diff] [blame] | 56 | * These configurations take effect for the next track played (not the current track). |
| 57 | */ |
| 58 | |
| 59 | static inline bool getUseAudioCallbackSetting() { |
| 60 | return property_get_bool("media.stagefright.audio.cbk", false /* default_value */); |
| 61 | } |
| 62 | |
Andy Hung | 179652e | 2015-05-31 22:49:46 -0700 | [diff] [blame] | 63 | static inline int32_t getAudioSinkPcmMsSetting() { |
| 64 | return property_get_int32( |
| 65 | "media.stagefright.audio.sink", 500 /* default_value */); |
| 66 | } |
| 67 | |
Ronghua Wu | f5b1db1 | 2014-09-09 10:11:08 -0700 | [diff] [blame] | 68 | // Maximum time in paused state when offloading audio decompression. When elapsed, the AudioSink |
| 69 | // is closed to allow the audio DSP to power down. |
Eric Laurent | a5d316f | 2014-10-29 15:32:17 -0700 | [diff] [blame] | 70 | static const int64_t kOffloadPauseMaxUs = 10000000ll; |
Ronghua Wu | f5b1db1 | 2014-09-09 10:11:08 -0700 | [diff] [blame] | 71 | |
Andreas Huber | 714aa7b | 2011-09-13 08:28:38 -0700 | [diff] [blame] | 72 | // static |
Andy Hung | f0e8364 | 2014-12-19 17:55:56 -0800 | [diff] [blame] | 73 | const NuPlayer::Renderer::PcmInfo NuPlayer::Renderer::AUDIO_PCMINFO_INITIALIZER = { |
| 74 | AUDIO_CHANNEL_NONE, |
| 75 | AUDIO_OUTPUT_FLAG_NONE, |
| 76 | AUDIO_FORMAT_INVALID, |
| 77 | 0, // mNumChannels |
| 78 | 0 // mSampleRate |
| 79 | }; |
| 80 | |
| 81 | // static |
Andreas Huber | 714aa7b | 2011-09-13 08:28:38 -0700 | [diff] [blame] | 82 | const int64_t NuPlayer::Renderer::kMinPositionUpdateDelayUs = 100000ll; |
| 83 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 84 | NuPlayer::Renderer::Renderer( |
| 85 | const sp<MediaPlayerBase::AudioSink> &sink, |
Andreas Huber | d5e5623 | 2013-03-12 11:01:43 -0700 | [diff] [blame] | 86 | const sp<AMessage> ¬ify, |
| 87 | uint32_t flags) |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 88 | : mAudioSink(sink), |
| 89 | mNotify(notify), |
Andreas Huber | d5e5623 | 2013-03-12 11:01:43 -0700 | [diff] [blame] | 90 | mFlags(flags), |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 91 | mNumFramesWritten(0), |
| 92 | mDrainAudioQueuePending(false), |
| 93 | mDrainVideoQueuePending(false), |
| 94 | mAudioQueueGeneration(0), |
| 95 | mVideoQueueGeneration(0), |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 96 | mAudioDrainGeneration(0), |
| 97 | mVideoDrainGeneration(0), |
Wei Jia | 7c8d0e0 | 2015-08-27 17:40:21 -0700 | [diff] [blame] | 98 | mAudioEOSGeneration(0), |
Lajos Molnar | 3a474aa | 2015-04-24 17:10:07 -0700 | [diff] [blame] | 99 | mPlaybackSettings(AUDIO_PLAYBACK_RATE_DEFAULT), |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 100 | mAudioFirstAnchorTimeMediaUs(-1), |
Ronghua Wu | eecb780 | 2014-10-19 23:12:50 -0700 | [diff] [blame] | 101 | mAnchorTimeMediaUs(-1), |
Lajos Molnar | f592671 | 2014-10-21 09:36:43 -0700 | [diff] [blame] | 102 | mAnchorNumFramesWritten(-1), |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 103 | mVideoLateByUs(0ll), |
Andreas Huber | bc7f5b2 | 2011-01-21 10:15:23 -0800 | [diff] [blame] | 104 | mHasAudio(false), |
| 105 | mHasVideo(false), |
Chong Zhang | 7137ec7 | 2014-11-12 16:41:05 -0800 | [diff] [blame] | 106 | mNotifyCompleteAudio(false), |
| 107 | mNotifyCompleteVideo(false), |
Andreas Huber | bc7f5b2 | 2011-01-21 10:15:23 -0800 | [diff] [blame] | 108 | mSyncQueues(false), |
Andreas Huber | 714aa7b | 2011-09-13 08:28:38 -0700 | [diff] [blame] | 109 | mPaused(false), |
Andy Hung | b03dcb3 | 2015-08-27 16:18:59 -0700 | [diff] [blame] | 110 | mPauseDrainAudioAllowedUs(0), |
Andy Hung | 09e0c36 | 2014-09-12 15:12:16 -0700 | [diff] [blame] | 111 | mVideoSampleReceived(false), |
James Dong | f57b4ea | 2012-07-20 13:38:36 -0700 | [diff] [blame] | 112 | mVideoRenderingStarted(false), |
Lajos Molnar | cbaffcf | 2013-08-14 18:30:38 -0700 | [diff] [blame] | 113 | mVideoRenderingStartGeneration(0), |
| 114 | mAudioRenderingStartGeneration(0), |
Andy Hung | b12ea0b | 2015-09-03 15:13:01 -0700 | [diff] [blame^] | 115 | mRenderingDataDelivered(false), |
Wei Jia | 2995dc7 | 2015-07-24 16:00:33 -0700 | [diff] [blame] | 116 | mLastAudioMediaTimeUs(-1), |
Ronghua Wu | f5b1db1 | 2014-09-09 10:11:08 -0700 | [diff] [blame] | 117 | mAudioOffloadPauseTimeoutGeneration(0), |
Ronghua Wu | faeb0f2 | 2015-05-21 12:20:21 -0700 | [diff] [blame] | 118 | mAudioTornDown(false), |
Lajos Molnar | d592340 | 2014-10-20 17:47:54 -0700 | [diff] [blame] | 119 | mCurrentOffloadInfo(AUDIO_INFO_INITIALIZER), |
Andy Hung | f0e8364 | 2014-12-19 17:55:56 -0800 | [diff] [blame] | 120 | mCurrentPcmInfo(AUDIO_PCMINFO_INITIALIZER), |
Lajos Molnar | d592340 | 2014-10-20 17:47:54 -0700 | [diff] [blame] | 121 | mTotalBuffersQueued(0), |
Weiyin Jiang | 35d5af1 | 2015-01-28 16:14:02 +0800 | [diff] [blame] | 122 | mLastAudioBufferDrained(0), |
Andy Hung | a0b3971 | 2015-05-31 22:40:49 -0700 | [diff] [blame] | 123 | mUseAudioCallback(false), |
Weiyin Jiang | 35d5af1 | 2015-01-28 16:14:02 +0800 | [diff] [blame] | 124 | mWakeLock(new AWakeLock()) { |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 125 | mMediaClock = new MediaClock; |
Lajos Molnar | 3a474aa | 2015-04-24 17:10:07 -0700 | [diff] [blame] | 126 | mPlaybackRate = mPlaybackSettings.mSpeed; |
| 127 | mMediaClock->setPlaybackRate(mPlaybackRate); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 128 | } |
| 129 | |
| 130 | NuPlayer::Renderer::~Renderer() { |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 131 | if (offloadingAudio()) { |
| 132 | mAudioSink->stop(); |
| 133 | mAudioSink->flush(); |
| 134 | mAudioSink->close(); |
| 135 | } |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 136 | } |
| 137 | |
| 138 | void NuPlayer::Renderer::queueBuffer( |
| 139 | bool audio, |
| 140 | const sp<ABuffer> &buffer, |
| 141 | const sp<AMessage> ¬ifyConsumed) { |
Lajos Molnar | 1d15ab5 | 2015-03-04 16:46:34 -0800 | [diff] [blame] | 142 | sp<AMessage> msg = new AMessage(kWhatQueueBuffer, this); |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 143 | msg->setInt32("queueGeneration", getQueueGeneration(audio)); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 144 | msg->setInt32("audio", static_cast<int32_t>(audio)); |
Andreas Huber | 2d8bedd | 2012-02-21 14:38:23 -0800 | [diff] [blame] | 145 | msg->setBuffer("buffer", buffer); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 146 | msg->setMessage("notifyConsumed", notifyConsumed); |
| 147 | msg->post(); |
| 148 | } |
| 149 | |
| 150 | void NuPlayer::Renderer::queueEOS(bool audio, status_t finalResult) { |
| 151 | CHECK_NE(finalResult, (status_t)OK); |
| 152 | |
Lajos Molnar | 1d15ab5 | 2015-03-04 16:46:34 -0800 | [diff] [blame] | 153 | sp<AMessage> msg = new AMessage(kWhatQueueEOS, this); |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 154 | msg->setInt32("queueGeneration", getQueueGeneration(audio)); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 155 | msg->setInt32("audio", static_cast<int32_t>(audio)); |
| 156 | msg->setInt32("finalResult", finalResult); |
| 157 | msg->post(); |
| 158 | } |
| 159 | |
Lajos Molnar | 3a474aa | 2015-04-24 17:10:07 -0700 | [diff] [blame] | 160 | status_t NuPlayer::Renderer::setPlaybackSettings(const AudioPlaybackRate &rate) { |
| 161 | sp<AMessage> msg = new AMessage(kWhatConfigPlayback, this); |
| 162 | writeToAMessage(msg, rate); |
| 163 | sp<AMessage> response; |
| 164 | status_t err = msg->postAndAwaitResponse(&response); |
| 165 | if (err == OK && response != NULL) { |
| 166 | CHECK(response->findInt32("err", &err)); |
| 167 | } |
| 168 | return err; |
| 169 | } |
| 170 | |
| 171 | status_t NuPlayer::Renderer::onConfigPlayback(const AudioPlaybackRate &rate /* sanitized */) { |
| 172 | if (rate.mSpeed == 0.f) { |
| 173 | onPause(); |
| 174 | // don't call audiosink's setPlaybackRate if pausing, as pitch does not |
| 175 | // have to correspond to the any non-0 speed (e.g old speed). Keep |
| 176 | // settings nonetheless, using the old speed, in case audiosink changes. |
| 177 | AudioPlaybackRate newRate = rate; |
| 178 | newRate.mSpeed = mPlaybackSettings.mSpeed; |
| 179 | mPlaybackSettings = newRate; |
| 180 | return OK; |
| 181 | } |
| 182 | |
Wei Jia | 27ea08e | 2015-05-12 14:50:35 -0700 | [diff] [blame] | 183 | if (mAudioSink != NULL && mAudioSink->ready()) { |
Lajos Molnar | 3a474aa | 2015-04-24 17:10:07 -0700 | [diff] [blame] | 184 | status_t err = mAudioSink->setPlaybackRate(rate); |
| 185 | if (err != OK) { |
| 186 | return err; |
| 187 | } |
| 188 | } |
| 189 | mPlaybackSettings = rate; |
| 190 | mPlaybackRate = rate.mSpeed; |
| 191 | mMediaClock->setPlaybackRate(mPlaybackRate); |
| 192 | return OK; |
| 193 | } |
| 194 | |
| 195 | status_t NuPlayer::Renderer::getPlaybackSettings(AudioPlaybackRate *rate /* nonnull */) { |
| 196 | sp<AMessage> msg = new AMessage(kWhatGetPlaybackSettings, this); |
| 197 | sp<AMessage> response; |
| 198 | status_t err = msg->postAndAwaitResponse(&response); |
| 199 | if (err == OK && response != NULL) { |
| 200 | CHECK(response->findInt32("err", &err)); |
| 201 | if (err == OK) { |
| 202 | readFromAMessage(response, rate); |
| 203 | } |
| 204 | } |
| 205 | return err; |
| 206 | } |
| 207 | |
| 208 | status_t NuPlayer::Renderer::onGetPlaybackSettings(AudioPlaybackRate *rate /* nonnull */) { |
Wei Jia | 27ea08e | 2015-05-12 14:50:35 -0700 | [diff] [blame] | 209 | if (mAudioSink != NULL && mAudioSink->ready()) { |
Lajos Molnar | 3a474aa | 2015-04-24 17:10:07 -0700 | [diff] [blame] | 210 | status_t err = mAudioSink->getPlaybackRate(rate); |
| 211 | if (err == OK) { |
| 212 | if (!isAudioPlaybackRateEqual(*rate, mPlaybackSettings)) { |
| 213 | ALOGW("correcting mismatch in internal/external playback rate"); |
| 214 | } |
| 215 | // get playback settings used by audiosink, as it may be |
| 216 | // slightly off due to audiosink not taking small changes. |
| 217 | mPlaybackSettings = *rate; |
| 218 | if (mPaused) { |
| 219 | rate->mSpeed = 0.f; |
| 220 | } |
| 221 | } |
| 222 | return err; |
| 223 | } |
| 224 | *rate = mPlaybackSettings; |
| 225 | return OK; |
| 226 | } |
| 227 | |
| 228 | status_t NuPlayer::Renderer::setSyncSettings(const AVSyncSettings &sync, float videoFpsHint) { |
| 229 | sp<AMessage> msg = new AMessage(kWhatConfigSync, this); |
| 230 | writeToAMessage(msg, sync, videoFpsHint); |
| 231 | sp<AMessage> response; |
| 232 | status_t err = msg->postAndAwaitResponse(&response); |
| 233 | if (err == OK && response != NULL) { |
| 234 | CHECK(response->findInt32("err", &err)); |
| 235 | } |
| 236 | return err; |
| 237 | } |
| 238 | |
| 239 | status_t NuPlayer::Renderer::onConfigSync(const AVSyncSettings &sync, float videoFpsHint __unused) { |
| 240 | if (sync.mSource != AVSYNC_SOURCE_DEFAULT) { |
| 241 | return BAD_VALUE; |
| 242 | } |
| 243 | // TODO: support sync sources |
| 244 | return INVALID_OPERATION; |
| 245 | } |
| 246 | |
| 247 | status_t NuPlayer::Renderer::getSyncSettings(AVSyncSettings *sync, float *videoFps) { |
| 248 | sp<AMessage> msg = new AMessage(kWhatGetSyncSettings, this); |
| 249 | sp<AMessage> response; |
| 250 | status_t err = msg->postAndAwaitResponse(&response); |
| 251 | if (err == OK && response != NULL) { |
| 252 | CHECK(response->findInt32("err", &err)); |
| 253 | if (err == OK) { |
| 254 | readFromAMessage(response, sync, videoFps); |
| 255 | } |
| 256 | } |
| 257 | return err; |
| 258 | } |
| 259 | |
| 260 | status_t NuPlayer::Renderer::onGetSyncSettings( |
| 261 | AVSyncSettings *sync /* nonnull */, float *videoFps /* nonnull */) { |
| 262 | *sync = mSyncSettings; |
| 263 | *videoFps = -1.f; |
| 264 | return OK; |
Wei Jia | 9816016 | 2015-02-04 17:01:11 -0800 | [diff] [blame] | 265 | } |
| 266 | |
Chong Zhang | 7137ec7 | 2014-11-12 16:41:05 -0800 | [diff] [blame] | 267 | void NuPlayer::Renderer::flush(bool audio, bool notifyComplete) { |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 268 | { |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 269 | Mutex::Autolock autoLock(mLock); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 270 | if (audio) { |
Chong Zhang | 7137ec7 | 2014-11-12 16:41:05 -0800 | [diff] [blame] | 271 | mNotifyCompleteAudio |= notifyComplete; |
Wei Jia | 3b0cd26 | 2015-07-13 11:28:10 -0700 | [diff] [blame] | 272 | clearAudioFirstAnchorTime_l(); |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 273 | ++mAudioQueueGeneration; |
| 274 | ++mAudioDrainGeneration; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 275 | } else { |
Chong Zhang | 7137ec7 | 2014-11-12 16:41:05 -0800 | [diff] [blame] | 276 | mNotifyCompleteVideo |= notifyComplete; |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 277 | ++mVideoQueueGeneration; |
| 278 | ++mVideoDrainGeneration; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 279 | } |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 280 | |
| 281 | clearAnchorTime_l(); |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 282 | mVideoLateByUs = 0; |
| 283 | mSyncQueues = false; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 284 | } |
| 285 | |
Lajos Molnar | 1d15ab5 | 2015-03-04 16:46:34 -0800 | [diff] [blame] | 286 | sp<AMessage> msg = new AMessage(kWhatFlush, this); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 287 | msg->setInt32("audio", static_cast<int32_t>(audio)); |
| 288 | msg->post(); |
| 289 | } |
| 290 | |
| 291 | void NuPlayer::Renderer::signalTimeDiscontinuity() { |
Wei Jia | 28a8a9f | 2014-08-18 11:29:50 -0700 | [diff] [blame] | 292 | } |
| 293 | |
| 294 | void NuPlayer::Renderer::signalDisableOffloadAudio() { |
Lajos Molnar | 1d15ab5 | 2015-03-04 16:46:34 -0800 | [diff] [blame] | 295 | (new AMessage(kWhatDisableOffloadAudio, this))->post(); |
Wei Jia | 28a8a9f | 2014-08-18 11:29:50 -0700 | [diff] [blame] | 296 | } |
| 297 | |
Ronghua Wu | a10fd23 | 2014-11-06 16:15:20 -0800 | [diff] [blame] | 298 | void NuPlayer::Renderer::signalEnableOffloadAudio() { |
Lajos Molnar | 1d15ab5 | 2015-03-04 16:46:34 -0800 | [diff] [blame] | 299 | (new AMessage(kWhatEnableOffloadAudio, this))->post(); |
Ronghua Wu | a10fd23 | 2014-11-06 16:15:20 -0800 | [diff] [blame] | 300 | } |
| 301 | |
Andreas Huber | b408222 | 2011-01-20 15:23:04 -0800 | [diff] [blame] | 302 | void NuPlayer::Renderer::pause() { |
Lajos Molnar | 1d15ab5 | 2015-03-04 16:46:34 -0800 | [diff] [blame] | 303 | (new AMessage(kWhatPause, this))->post(); |
Andreas Huber | b408222 | 2011-01-20 15:23:04 -0800 | [diff] [blame] | 304 | } |
| 305 | |
| 306 | void NuPlayer::Renderer::resume() { |
Lajos Molnar | 1d15ab5 | 2015-03-04 16:46:34 -0800 | [diff] [blame] | 307 | (new AMessage(kWhatResume, this))->post(); |
Andreas Huber | b408222 | 2011-01-20 15:23:04 -0800 | [diff] [blame] | 308 | } |
| 309 | |
Lajos Molnar | c851b5d | 2014-09-18 14:14:29 -0700 | [diff] [blame] | 310 | void NuPlayer::Renderer::setVideoFrameRate(float fps) { |
Lajos Molnar | 1d15ab5 | 2015-03-04 16:46:34 -0800 | [diff] [blame] | 311 | sp<AMessage> msg = new AMessage(kWhatSetVideoFrameRate, this); |
Lajos Molnar | c851b5d | 2014-09-18 14:14:29 -0700 | [diff] [blame] | 312 | msg->setFloat("frame-rate", fps); |
| 313 | msg->post(); |
| 314 | } |
| 315 | |
Wei Jia | d4cdba1 | 2014-12-18 10:44:17 -0800 | [diff] [blame] | 316 | // Called on any threads. |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 317 | status_t NuPlayer::Renderer::getCurrentPosition(int64_t *mediaUs) { |
Wei Jia | 9816016 | 2015-02-04 17:01:11 -0800 | [diff] [blame] | 318 | return mMediaClock->getMediaTime(ALooper::GetNowUs(), mediaUs); |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 319 | } |
| 320 | |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 321 | void NuPlayer::Renderer::clearAudioFirstAnchorTime_l() { |
| 322 | mAudioFirstAnchorTimeMediaUs = -1; |
| 323 | mMediaClock->setStartingTimeMedia(-1); |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 324 | } |
| 325 | |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 326 | void NuPlayer::Renderer::setAudioFirstAnchorTimeIfNeeded_l(int64_t mediaUs) { |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 327 | if (mAudioFirstAnchorTimeMediaUs == -1) { |
| 328 | mAudioFirstAnchorTimeMediaUs = mediaUs; |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 329 | mMediaClock->setStartingTimeMedia(mediaUs); |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 330 | } |
| 331 | } |
| 332 | |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 333 | void NuPlayer::Renderer::clearAnchorTime_l() { |
| 334 | mMediaClock->clearAnchor(); |
| 335 | mAnchorTimeMediaUs = -1; |
| 336 | mAnchorNumFramesWritten = -1; |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 337 | } |
| 338 | |
| 339 | void NuPlayer::Renderer::setVideoLateByUs(int64_t lateUs) { |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 340 | Mutex::Autolock autoLock(mLock); |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 341 | mVideoLateByUs = lateUs; |
| 342 | } |
| 343 | |
| 344 | int64_t NuPlayer::Renderer::getVideoLateByUs() { |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 345 | Mutex::Autolock autoLock(mLock); |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 346 | return mVideoLateByUs; |
| 347 | } |
| 348 | |
Andy Hung | 202bce1 | 2014-12-03 11:47:36 -0800 | [diff] [blame] | 349 | status_t NuPlayer::Renderer::openAudioSink( |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 350 | const sp<AMessage> &format, |
| 351 | bool offloadOnly, |
| 352 | bool hasVideo, |
Andy Hung | 202bce1 | 2014-12-03 11:47:36 -0800 | [diff] [blame] | 353 | uint32_t flags, |
| 354 | bool *isOffloaded) { |
Lajos Molnar | 1d15ab5 | 2015-03-04 16:46:34 -0800 | [diff] [blame] | 355 | sp<AMessage> msg = new AMessage(kWhatOpenAudioSink, this); |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 356 | msg->setMessage("format", format); |
| 357 | msg->setInt32("offload-only", offloadOnly); |
| 358 | msg->setInt32("has-video", hasVideo); |
| 359 | msg->setInt32("flags", flags); |
| 360 | |
| 361 | sp<AMessage> response; |
| 362 | msg->postAndAwaitResponse(&response); |
| 363 | |
Andy Hung | 202bce1 | 2014-12-03 11:47:36 -0800 | [diff] [blame] | 364 | int32_t err; |
| 365 | if (!response->findInt32("err", &err)) { |
| 366 | err = INVALID_OPERATION; |
| 367 | } else if (err == OK && isOffloaded != NULL) { |
| 368 | int32_t offload; |
| 369 | CHECK(response->findInt32("offload", &offload)); |
| 370 | *isOffloaded = (offload != 0); |
| 371 | } |
| 372 | return err; |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 373 | } |
| 374 | |
| 375 | void NuPlayer::Renderer::closeAudioSink() { |
Lajos Molnar | 1d15ab5 | 2015-03-04 16:46:34 -0800 | [diff] [blame] | 376 | sp<AMessage> msg = new AMessage(kWhatCloseAudioSink, this); |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 377 | |
| 378 | sp<AMessage> response; |
| 379 | msg->postAndAwaitResponse(&response); |
| 380 | } |
| 381 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 382 | void NuPlayer::Renderer::onMessageReceived(const sp<AMessage> &msg) { |
| 383 | switch (msg->what()) { |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 384 | case kWhatOpenAudioSink: |
| 385 | { |
| 386 | sp<AMessage> format; |
| 387 | CHECK(msg->findMessage("format", &format)); |
| 388 | |
| 389 | int32_t offloadOnly; |
| 390 | CHECK(msg->findInt32("offload-only", &offloadOnly)); |
| 391 | |
| 392 | int32_t hasVideo; |
| 393 | CHECK(msg->findInt32("has-video", &hasVideo)); |
| 394 | |
| 395 | uint32_t flags; |
| 396 | CHECK(msg->findInt32("flags", (int32_t *)&flags)); |
| 397 | |
Andy Hung | 202bce1 | 2014-12-03 11:47:36 -0800 | [diff] [blame] | 398 | status_t err = onOpenAudioSink(format, offloadOnly, hasVideo, flags); |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 399 | |
| 400 | sp<AMessage> response = new AMessage; |
Andy Hung | 202bce1 | 2014-12-03 11:47:36 -0800 | [diff] [blame] | 401 | response->setInt32("err", err); |
| 402 | response->setInt32("offload", offloadingAudio()); |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 403 | |
Lajos Molnar | 3f27436 | 2015-03-05 14:35:41 -0800 | [diff] [blame] | 404 | sp<AReplyToken> replyID; |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 405 | CHECK(msg->senderAwaitsResponse(&replyID)); |
| 406 | response->postReply(replyID); |
| 407 | |
| 408 | break; |
| 409 | } |
| 410 | |
| 411 | case kWhatCloseAudioSink: |
| 412 | { |
Lajos Molnar | 3f27436 | 2015-03-05 14:35:41 -0800 | [diff] [blame] | 413 | sp<AReplyToken> replyID; |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 414 | CHECK(msg->senderAwaitsResponse(&replyID)); |
| 415 | |
| 416 | onCloseAudioSink(); |
| 417 | |
| 418 | sp<AMessage> response = new AMessage; |
| 419 | response->postReply(replyID); |
| 420 | break; |
| 421 | } |
| 422 | |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 423 | case kWhatStopAudioSink: |
| 424 | { |
| 425 | mAudioSink->stop(); |
| 426 | break; |
| 427 | } |
| 428 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 429 | case kWhatDrainAudioQueue: |
| 430 | { |
Wei Jia | 3ab2545 | 2015-06-10 09:37:47 -0700 | [diff] [blame] | 431 | mDrainAudioQueuePending = false; |
| 432 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 433 | int32_t generation; |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 434 | CHECK(msg->findInt32("drainGeneration", &generation)); |
| 435 | if (generation != getDrainGeneration(true /* audio */)) { |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 436 | break; |
| 437 | } |
| 438 | |
Andreas Huber | 078cfcf | 2011-09-15 12:25:04 -0700 | [diff] [blame] | 439 | if (onDrainAudioQueue()) { |
| 440 | uint32_t numFramesPlayed; |
| 441 | CHECK_EQ(mAudioSink->getPosition(&numFramesPlayed), |
| 442 | (status_t)OK); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 443 | |
Andreas Huber | 078cfcf | 2011-09-15 12:25:04 -0700 | [diff] [blame] | 444 | uint32_t numFramesPendingPlayout = |
| 445 | mNumFramesWritten - numFramesPlayed; |
| 446 | |
| 447 | // This is how long the audio sink will have data to |
| 448 | // play back. |
| 449 | int64_t delayUs = |
| 450 | mAudioSink->msecsPerFrame() |
| 451 | * numFramesPendingPlayout * 1000ll; |
Wei Jia | d9c2e9c | 2015-04-10 19:04:09 -0700 | [diff] [blame] | 452 | if (mPlaybackRate > 1.0f) { |
| 453 | delayUs /= mPlaybackRate; |
| 454 | } |
Andreas Huber | 078cfcf | 2011-09-15 12:25:04 -0700 | [diff] [blame] | 455 | |
| 456 | // Let's give it more data after about half that time |
| 457 | // has elapsed. |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 458 | Mutex::Autolock autoLock(mLock); |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 459 | postDrainAudioQueue_l(delayUs / 2); |
Andreas Huber | 078cfcf | 2011-09-15 12:25:04 -0700 | [diff] [blame] | 460 | } |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 461 | break; |
| 462 | } |
| 463 | |
| 464 | case kWhatDrainVideoQueue: |
| 465 | { |
| 466 | int32_t generation; |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 467 | CHECK(msg->findInt32("drainGeneration", &generation)); |
| 468 | if (generation != getDrainGeneration(false /* audio */)) { |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 469 | break; |
| 470 | } |
| 471 | |
| 472 | mDrainVideoQueuePending = false; |
| 473 | |
| 474 | onDrainVideoQueue(); |
| 475 | |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 476 | postDrainVideoQueue(); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 477 | break; |
| 478 | } |
| 479 | |
Lajos Molnar | d592340 | 2014-10-20 17:47:54 -0700 | [diff] [blame] | 480 | case kWhatPostDrainVideoQueue: |
| 481 | { |
| 482 | int32_t generation; |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 483 | CHECK(msg->findInt32("drainGeneration", &generation)); |
| 484 | if (generation != getDrainGeneration(false /* audio */)) { |
Lajos Molnar | d592340 | 2014-10-20 17:47:54 -0700 | [diff] [blame] | 485 | break; |
| 486 | } |
| 487 | |
| 488 | mDrainVideoQueuePending = false; |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 489 | postDrainVideoQueue(); |
Lajos Molnar | d592340 | 2014-10-20 17:47:54 -0700 | [diff] [blame] | 490 | break; |
| 491 | } |
| 492 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 493 | case kWhatQueueBuffer: |
| 494 | { |
| 495 | onQueueBuffer(msg); |
| 496 | break; |
| 497 | } |
| 498 | |
| 499 | case kWhatQueueEOS: |
| 500 | { |
| 501 | onQueueEOS(msg); |
| 502 | break; |
| 503 | } |
| 504 | |
Wei Jia | 7c8d0e0 | 2015-08-27 17:40:21 -0700 | [diff] [blame] | 505 | case kWhatEOS: |
| 506 | { |
| 507 | int32_t generation; |
| 508 | CHECK(msg->findInt32("audioEOSGeneration", &generation)); |
| 509 | if (generation != mAudioEOSGeneration) { |
| 510 | break; |
| 511 | } |
| 512 | status_t finalResult; |
| 513 | CHECK(msg->findInt32("finalResult", &finalResult)); |
| 514 | notifyEOS(true /* audio */, finalResult); |
| 515 | break; |
| 516 | } |
| 517 | |
Lajos Molnar | 3a474aa | 2015-04-24 17:10:07 -0700 | [diff] [blame] | 518 | case kWhatConfigPlayback: |
Wei Jia | 9816016 | 2015-02-04 17:01:11 -0800 | [diff] [blame] | 519 | { |
Lajos Molnar | 3a474aa | 2015-04-24 17:10:07 -0700 | [diff] [blame] | 520 | sp<AReplyToken> replyID; |
| 521 | CHECK(msg->senderAwaitsResponse(&replyID)); |
| 522 | AudioPlaybackRate rate; |
| 523 | readFromAMessage(msg, &rate); |
| 524 | status_t err = onConfigPlayback(rate); |
| 525 | sp<AMessage> response = new AMessage; |
| 526 | response->setInt32("err", err); |
| 527 | response->postReply(replyID); |
| 528 | break; |
| 529 | } |
| 530 | |
| 531 | case kWhatGetPlaybackSettings: |
| 532 | { |
| 533 | sp<AReplyToken> replyID; |
| 534 | CHECK(msg->senderAwaitsResponse(&replyID)); |
| 535 | AudioPlaybackRate rate = AUDIO_PLAYBACK_RATE_DEFAULT; |
| 536 | status_t err = onGetPlaybackSettings(&rate); |
| 537 | sp<AMessage> response = new AMessage; |
| 538 | if (err == OK) { |
| 539 | writeToAMessage(response, rate); |
| 540 | } |
| 541 | response->setInt32("err", err); |
| 542 | response->postReply(replyID); |
| 543 | break; |
| 544 | } |
| 545 | |
| 546 | case kWhatConfigSync: |
| 547 | { |
| 548 | sp<AReplyToken> replyID; |
| 549 | CHECK(msg->senderAwaitsResponse(&replyID)); |
| 550 | AVSyncSettings sync; |
| 551 | float videoFpsHint; |
| 552 | readFromAMessage(msg, &sync, &videoFpsHint); |
| 553 | status_t err = onConfigSync(sync, videoFpsHint); |
| 554 | sp<AMessage> response = new AMessage; |
| 555 | response->setInt32("err", err); |
| 556 | response->postReply(replyID); |
| 557 | break; |
| 558 | } |
| 559 | |
| 560 | case kWhatGetSyncSettings: |
| 561 | { |
| 562 | sp<AReplyToken> replyID; |
| 563 | CHECK(msg->senderAwaitsResponse(&replyID)); |
| 564 | |
| 565 | ALOGV("kWhatGetSyncSettings"); |
| 566 | AVSyncSettings sync; |
| 567 | float videoFps = -1.f; |
| 568 | status_t err = onGetSyncSettings(&sync, &videoFps); |
| 569 | sp<AMessage> response = new AMessage; |
| 570 | if (err == OK) { |
| 571 | writeToAMessage(response, sync, videoFps); |
| 572 | } |
| 573 | response->setInt32("err", err); |
| 574 | response->postReply(replyID); |
Wei Jia | 9816016 | 2015-02-04 17:01:11 -0800 | [diff] [blame] | 575 | break; |
| 576 | } |
| 577 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 578 | case kWhatFlush: |
| 579 | { |
| 580 | onFlush(msg); |
| 581 | break; |
| 582 | } |
| 583 | |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 584 | case kWhatDisableOffloadAudio: |
| 585 | { |
| 586 | onDisableOffloadAudio(); |
| 587 | break; |
| 588 | } |
| 589 | |
Ronghua Wu | a10fd23 | 2014-11-06 16:15:20 -0800 | [diff] [blame] | 590 | case kWhatEnableOffloadAudio: |
| 591 | { |
| 592 | onEnableOffloadAudio(); |
| 593 | break; |
| 594 | } |
| 595 | |
Andreas Huber | b408222 | 2011-01-20 15:23:04 -0800 | [diff] [blame] | 596 | case kWhatPause: |
| 597 | { |
| 598 | onPause(); |
| 599 | break; |
| 600 | } |
| 601 | |
| 602 | case kWhatResume: |
| 603 | { |
| 604 | onResume(); |
| 605 | break; |
| 606 | } |
| 607 | |
Lajos Molnar | c851b5d | 2014-09-18 14:14:29 -0700 | [diff] [blame] | 608 | case kWhatSetVideoFrameRate: |
| 609 | { |
| 610 | float fps; |
| 611 | CHECK(msg->findFloat("frame-rate", &fps)); |
| 612 | onSetVideoFrameRate(fps); |
| 613 | break; |
| 614 | } |
| 615 | |
Ronghua Wu | faeb0f2 | 2015-05-21 12:20:21 -0700 | [diff] [blame] | 616 | case kWhatAudioTearDown: |
Wei Jia | 3a2956d | 2014-07-22 16:01:33 -0700 | [diff] [blame] | 617 | { |
Ronghua Wu | faeb0f2 | 2015-05-21 12:20:21 -0700 | [diff] [blame] | 618 | onAudioTearDown(kDueToError); |
Wei Jia | 3a2956d | 2014-07-22 16:01:33 -0700 | [diff] [blame] | 619 | break; |
| 620 | } |
| 621 | |
Ronghua Wu | f5b1db1 | 2014-09-09 10:11:08 -0700 | [diff] [blame] | 622 | case kWhatAudioOffloadPauseTimeout: |
| 623 | { |
| 624 | int32_t generation; |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 625 | CHECK(msg->findInt32("drainGeneration", &generation)); |
Ronghua Wu | f5b1db1 | 2014-09-09 10:11:08 -0700 | [diff] [blame] | 626 | if (generation != mAudioOffloadPauseTimeoutGeneration) { |
| 627 | break; |
| 628 | } |
Ronghua Wu | 0852917 | 2014-10-02 16:55:52 -0700 | [diff] [blame] | 629 | ALOGV("Audio Offload tear down due to pause timeout."); |
Ronghua Wu | faeb0f2 | 2015-05-21 12:20:21 -0700 | [diff] [blame] | 630 | onAudioTearDown(kDueToTimeout); |
Weiyin Jiang | 35d5af1 | 2015-01-28 16:14:02 +0800 | [diff] [blame] | 631 | mWakeLock->release(); |
Ronghua Wu | f5b1db1 | 2014-09-09 10:11:08 -0700 | [diff] [blame] | 632 | break; |
| 633 | } |
| 634 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 635 | default: |
| 636 | TRESPASS(); |
| 637 | break; |
| 638 | } |
| 639 | } |
| 640 | |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 641 | void NuPlayer::Renderer::postDrainAudioQueue_l(int64_t delayUs) { |
Andy Hung | 005e9d0 | 2015-05-31 23:16:07 -0700 | [diff] [blame] | 642 | if (mDrainAudioQueuePending || mSyncQueues || mUseAudioCallback) { |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 643 | return; |
| 644 | } |
| 645 | |
| 646 | if (mAudioQueue.empty()) { |
| 647 | return; |
| 648 | } |
| 649 | |
Andy Hung | b03dcb3 | 2015-08-27 16:18:59 -0700 | [diff] [blame] | 650 | // FIXME: if paused, wait until AudioTrack stop() is complete before delivering data. |
| 651 | if (mPaused) { |
| 652 | const int64_t diffUs = mPauseDrainAudioAllowedUs - ALooper::GetNowUs(); |
| 653 | if (diffUs > delayUs) { |
| 654 | delayUs = diffUs; |
| 655 | } |
| 656 | } |
| 657 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 658 | mDrainAudioQueuePending = true; |
Lajos Molnar | 1d15ab5 | 2015-03-04 16:46:34 -0800 | [diff] [blame] | 659 | sp<AMessage> msg = new AMessage(kWhatDrainAudioQueue, this); |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 660 | msg->setInt32("drainGeneration", mAudioDrainGeneration); |
Andreas Huber | 078cfcf | 2011-09-15 12:25:04 -0700 | [diff] [blame] | 661 | msg->post(delayUs); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 662 | } |
| 663 | |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 664 | void NuPlayer::Renderer::prepareForMediaRenderingStart_l() { |
| 665 | mAudioRenderingStartGeneration = mAudioDrainGeneration; |
| 666 | mVideoRenderingStartGeneration = mVideoDrainGeneration; |
Andy Hung | b12ea0b | 2015-09-03 15:13:01 -0700 | [diff] [blame^] | 667 | mRenderingDataDelivered = false; |
Lajos Molnar | cbaffcf | 2013-08-14 18:30:38 -0700 | [diff] [blame] | 668 | } |
| 669 | |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 670 | void NuPlayer::Renderer::notifyIfMediaRenderingStarted_l() { |
| 671 | if (mVideoRenderingStartGeneration == mVideoDrainGeneration && |
| 672 | mAudioRenderingStartGeneration == mAudioDrainGeneration) { |
Andy Hung | b12ea0b | 2015-09-03 15:13:01 -0700 | [diff] [blame^] | 673 | mRenderingDataDelivered = true; |
| 674 | if (mPaused) { |
| 675 | return; |
| 676 | } |
Lajos Molnar | cbaffcf | 2013-08-14 18:30:38 -0700 | [diff] [blame] | 677 | mVideoRenderingStartGeneration = -1; |
| 678 | mAudioRenderingStartGeneration = -1; |
| 679 | |
| 680 | sp<AMessage> notify = mNotify->dup(); |
| 681 | notify->setInt32("what", kWhatMediaRenderingStart); |
| 682 | notify->post(); |
| 683 | } |
| 684 | } |
| 685 | |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 686 | // static |
| 687 | size_t NuPlayer::Renderer::AudioSinkCallback( |
| 688 | MediaPlayerBase::AudioSink * /* audioSink */, |
| 689 | void *buffer, |
| 690 | size_t size, |
| 691 | void *cookie, |
| 692 | MediaPlayerBase::AudioSink::cb_event_t event) { |
| 693 | NuPlayer::Renderer *me = (NuPlayer::Renderer *)cookie; |
| 694 | |
| 695 | switch (event) { |
| 696 | case MediaPlayerBase::AudioSink::CB_EVENT_FILL_BUFFER: |
| 697 | { |
| 698 | return me->fillAudioBuffer(buffer, size); |
| 699 | break; |
| 700 | } |
| 701 | |
| 702 | case MediaPlayerBase::AudioSink::CB_EVENT_STREAM_END: |
| 703 | { |
Andy Hung | a0b3971 | 2015-05-31 22:40:49 -0700 | [diff] [blame] | 704 | ALOGV("AudioSink::CB_EVENT_STREAM_END"); |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 705 | me->notifyEOS(true /* audio */, ERROR_END_OF_STREAM); |
| 706 | break; |
| 707 | } |
| 708 | |
| 709 | case MediaPlayerBase::AudioSink::CB_EVENT_TEAR_DOWN: |
| 710 | { |
Andy Hung | a0b3971 | 2015-05-31 22:40:49 -0700 | [diff] [blame] | 711 | ALOGV("AudioSink::CB_EVENT_TEAR_DOWN"); |
Ronghua Wu | faeb0f2 | 2015-05-21 12:20:21 -0700 | [diff] [blame] | 712 | me->notifyAudioTearDown(); |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 713 | break; |
| 714 | } |
| 715 | } |
| 716 | |
| 717 | return 0; |
| 718 | } |
| 719 | |
| 720 | size_t NuPlayer::Renderer::fillAudioBuffer(void *buffer, size_t size) { |
| 721 | Mutex::Autolock autoLock(mLock); |
| 722 | |
Andy Hung | 85e4814 | 2015-05-31 23:04:15 -0700 | [diff] [blame] | 723 | if (!mUseAudioCallback) { |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 724 | return 0; |
| 725 | } |
| 726 | |
| 727 | bool hasEOS = false; |
| 728 | |
| 729 | size_t sizeCopied = 0; |
Ronghua Wu | 3e5efb3 | 2014-08-18 16:27:08 -0700 | [diff] [blame] | 730 | bool firstEntry = true; |
Andy Hung | a0b3971 | 2015-05-31 22:40:49 -0700 | [diff] [blame] | 731 | QueueEntry *entry; // will be valid after while loop if hasEOS is set. |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 732 | while (sizeCopied < size && !mAudioQueue.empty()) { |
Andy Hung | a0b3971 | 2015-05-31 22:40:49 -0700 | [diff] [blame] | 733 | entry = &*mAudioQueue.begin(); |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 734 | |
| 735 | if (entry->mBuffer == NULL) { // EOS |
| 736 | hasEOS = true; |
| 737 | mAudioQueue.erase(mAudioQueue.begin()); |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 738 | break; |
| 739 | } |
| 740 | |
Ronghua Wu | 3e5efb3 | 2014-08-18 16:27:08 -0700 | [diff] [blame] | 741 | if (firstEntry && entry->mOffset == 0) { |
| 742 | firstEntry = false; |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 743 | int64_t mediaTimeUs; |
| 744 | CHECK(entry->mBuffer->meta()->findInt64("timeUs", &mediaTimeUs)); |
Andy Hung | a0b3971 | 2015-05-31 22:40:49 -0700 | [diff] [blame] | 745 | ALOGV("fillAudioBuffer: rendering audio at media time %.2f secs", mediaTimeUs / 1E6); |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 746 | setAudioFirstAnchorTimeIfNeeded_l(mediaTimeUs); |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 747 | } |
| 748 | |
| 749 | size_t copy = entry->mBuffer->size() - entry->mOffset; |
| 750 | size_t sizeRemaining = size - sizeCopied; |
| 751 | if (copy > sizeRemaining) { |
| 752 | copy = sizeRemaining; |
| 753 | } |
| 754 | |
| 755 | memcpy((char *)buffer + sizeCopied, |
| 756 | entry->mBuffer->data() + entry->mOffset, |
| 757 | copy); |
| 758 | |
| 759 | entry->mOffset += copy; |
| 760 | if (entry->mOffset == entry->mBuffer->size()) { |
| 761 | entry->mNotifyConsumed->post(); |
| 762 | mAudioQueue.erase(mAudioQueue.begin()); |
| 763 | entry = NULL; |
| 764 | } |
| 765 | sizeCopied += copy; |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 766 | |
| 767 | notifyIfMediaRenderingStarted_l(); |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 768 | } |
| 769 | |
Lajos Molnar | f592671 | 2014-10-21 09:36:43 -0700 | [diff] [blame] | 770 | if (mAudioFirstAnchorTimeMediaUs >= 0) { |
| 771 | int64_t nowUs = ALooper::GetNowUs(); |
Wei Jia | 9816016 | 2015-02-04 17:01:11 -0800 | [diff] [blame] | 772 | int64_t nowMediaUs = |
| 773 | mAudioFirstAnchorTimeMediaUs + getPlayedOutAudioDurationUs(nowUs); |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 774 | // we don't know how much data we are queueing for offloaded tracks. |
Wei Jia | 9816016 | 2015-02-04 17:01:11 -0800 | [diff] [blame] | 775 | mMediaClock->updateAnchor(nowMediaUs, nowUs, INT64_MAX); |
Lajos Molnar | f592671 | 2014-10-21 09:36:43 -0700 | [diff] [blame] | 776 | } |
| 777 | |
Andy Hung | a0b3971 | 2015-05-31 22:40:49 -0700 | [diff] [blame] | 778 | // for non-offloaded audio, we need to compute the frames written because |
| 779 | // there is no EVENT_STREAM_END notification. The frames written gives |
| 780 | // an estimate on the pending played out duration. |
| 781 | if (!offloadingAudio()) { |
| 782 | mNumFramesWritten += sizeCopied / mAudioSink->frameSize(); |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 783 | } |
| 784 | |
Andy Hung | a0b3971 | 2015-05-31 22:40:49 -0700 | [diff] [blame] | 785 | if (hasEOS) { |
| 786 | (new AMessage(kWhatStopAudioSink, this))->post(); |
| 787 | // As there is currently no EVENT_STREAM_END callback notification for |
| 788 | // non-offloaded audio tracks, we need to post the EOS ourselves. |
| 789 | if (!offloadingAudio()) { |
| 790 | int64_t postEOSDelayUs = 0; |
| 791 | if (mAudioSink->needsTrailingPadding()) { |
| 792 | postEOSDelayUs = getPendingAudioPlayoutDurationUs(ALooper::GetNowUs()); |
| 793 | } |
| 794 | ALOGV("fillAudioBuffer: notifyEOS " |
| 795 | "mNumFramesWritten:%u finalResult:%d postEOSDelay:%lld", |
| 796 | mNumFramesWritten, entry->mFinalResult, (long long)postEOSDelayUs); |
| 797 | notifyEOS(true /* audio */, entry->mFinalResult, postEOSDelayUs); |
| 798 | } |
| 799 | } |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 800 | return sizeCopied; |
| 801 | } |
| 802 | |
Chong Zhang | 9da0ce4 | 2015-06-11 17:18:58 -0700 | [diff] [blame] | 803 | void NuPlayer::Renderer::drainAudioQueueUntilLastEOS() { |
| 804 | List<QueueEntry>::iterator it = mAudioQueue.begin(), itEOS = it; |
| 805 | bool foundEOS = false; |
| 806 | while (it != mAudioQueue.end()) { |
| 807 | int32_t eos; |
| 808 | QueueEntry *entry = &*it++; |
| 809 | if (entry->mBuffer == NULL |
| 810 | || (entry->mNotifyConsumed->findInt32("eos", &eos) && eos != 0)) { |
| 811 | itEOS = it; |
| 812 | foundEOS = true; |
| 813 | } |
| 814 | } |
| 815 | |
| 816 | if (foundEOS) { |
| 817 | // post all replies before EOS and drop the samples |
| 818 | for (it = mAudioQueue.begin(); it != itEOS; it++) { |
| 819 | if (it->mBuffer == NULL) { |
| 820 | // delay doesn't matter as we don't even have an AudioTrack |
| 821 | notifyEOS(true /* audio */, it->mFinalResult); |
| 822 | } else { |
| 823 | it->mNotifyConsumed->post(); |
| 824 | } |
| 825 | } |
| 826 | mAudioQueue.erase(mAudioQueue.begin(), itEOS); |
| 827 | } |
| 828 | } |
| 829 | |
Andreas Huber | 078cfcf | 2011-09-15 12:25:04 -0700 | [diff] [blame] | 830 | bool NuPlayer::Renderer::onDrainAudioQueue() { |
Wei Jia | 230b188 | 2015-03-19 15:13:51 -0700 | [diff] [blame] | 831 | // TODO: This call to getPosition checks if AudioTrack has been created |
| 832 | // in AudioSink before draining audio. If AudioTrack doesn't exist, then |
| 833 | // CHECKs on getPosition will fail. |
| 834 | // We still need to figure out why AudioTrack is not created when |
| 835 | // this function is called. One possible reason could be leftover |
| 836 | // audio. Another possible place is to check whether decoder |
| 837 | // has received INFO_FORMAT_CHANGED as the first buffer since |
| 838 | // AudioSink is opened there, and possible interactions with flush |
| 839 | // immediately after start. Investigate error message |
| 840 | // "vorbis_dsp_synthesis returned -135", along with RTSP. |
Andreas Huber | 078cfcf | 2011-09-15 12:25:04 -0700 | [diff] [blame] | 841 | uint32_t numFramesPlayed; |
Andreas Huber | 2bfdd42 | 2011-10-11 15:24:07 -0700 | [diff] [blame] | 842 | if (mAudioSink->getPosition(&numFramesPlayed) != OK) { |
Chong Zhang | 9da0ce4 | 2015-06-11 17:18:58 -0700 | [diff] [blame] | 843 | // When getPosition fails, renderer will not reschedule the draining |
| 844 | // unless new samples are queued. |
| 845 | // If we have pending EOS (or "eos" marker for discontinuities), we need |
| 846 | // to post these now as NuPlayerDecoder might be waiting for it. |
| 847 | drainAudioQueueUntilLastEOS(); |
| 848 | |
| 849 | ALOGW("onDrainAudioQueue(): audio sink is not ready"); |
Andreas Huber | 2bfdd42 | 2011-10-11 15:24:07 -0700 | [diff] [blame] | 850 | return false; |
| 851 | } |
Andreas Huber | c92fd24 | 2011-08-16 13:48:44 -0700 | [diff] [blame] | 852 | |
Wei Jia | 230b188 | 2015-03-19 15:13:51 -0700 | [diff] [blame] | 853 | #if 0 |
Andreas Huber | 078cfcf | 2011-09-15 12:25:04 -0700 | [diff] [blame] | 854 | ssize_t numFramesAvailableToWrite = |
| 855 | mAudioSink->frameCount() - (mNumFramesWritten - numFramesPlayed); |
| 856 | |
Andreas Huber | 078cfcf | 2011-09-15 12:25:04 -0700 | [diff] [blame] | 857 | if (numFramesAvailableToWrite == mAudioSink->frameCount()) { |
Steve Block | df64d15 | 2012-01-04 20:05:49 +0000 | [diff] [blame] | 858 | ALOGI("audio sink underrun"); |
Andreas Huber | 078cfcf | 2011-09-15 12:25:04 -0700 | [diff] [blame] | 859 | } else { |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 860 | ALOGV("audio queue has %d frames left to play", |
Andreas Huber | 078cfcf | 2011-09-15 12:25:04 -0700 | [diff] [blame] | 861 | mAudioSink->frameCount() - numFramesAvailableToWrite); |
| 862 | } |
| 863 | #endif |
| 864 | |
Andy Hung | 005e9d0 | 2015-05-31 23:16:07 -0700 | [diff] [blame] | 865 | uint32_t prevFramesWritten = mNumFramesWritten; |
Wei Jia | 7d3f4df | 2015-03-03 15:28:00 -0800 | [diff] [blame] | 866 | while (!mAudioQueue.empty()) { |
Andreas Huber | c92fd24 | 2011-08-16 13:48:44 -0700 | [diff] [blame] | 867 | QueueEntry *entry = &*mAudioQueue.begin(); |
| 868 | |
Lajos Molnar | d592340 | 2014-10-20 17:47:54 -0700 | [diff] [blame] | 869 | mLastAudioBufferDrained = entry->mBufferOrdinal; |
| 870 | |
Andreas Huber | c92fd24 | 2011-08-16 13:48:44 -0700 | [diff] [blame] | 871 | if (entry->mBuffer == NULL) { |
| 872 | // EOS |
Ronghua Wu | 5095d70 | 2014-08-27 12:05:48 -0700 | [diff] [blame] | 873 | int64_t postEOSDelayUs = 0; |
| 874 | if (mAudioSink->needsTrailingPadding()) { |
Lajos Molnar | 06ad152 | 2014-08-28 07:27:44 -0700 | [diff] [blame] | 875 | postEOSDelayUs = getPendingAudioPlayoutDurationUs(ALooper::GetNowUs()); |
Ronghua Wu | 5095d70 | 2014-08-27 12:05:48 -0700 | [diff] [blame] | 876 | } |
| 877 | notifyEOS(true /* audio */, entry->mFinalResult, postEOSDelayUs); |
Wei Jia | 2995dc7 | 2015-07-24 16:00:33 -0700 | [diff] [blame] | 878 | mLastAudioMediaTimeUs = getDurationUsIfPlayedAtSampleRate(mNumFramesWritten); |
Andreas Huber | c92fd24 | 2011-08-16 13:48:44 -0700 | [diff] [blame] | 879 | |
| 880 | mAudioQueue.erase(mAudioQueue.begin()); |
| 881 | entry = NULL; |
Andy Hung | 3491232 | 2014-12-18 18:48:39 -0800 | [diff] [blame] | 882 | if (mAudioSink->needsTrailingPadding()) { |
| 883 | // If we're not in gapless playback (i.e. through setNextPlayer), we |
| 884 | // need to stop the track here, because that will play out the last |
| 885 | // little bit at the end of the file. Otherwise short files won't play. |
| 886 | mAudioSink->stop(); |
| 887 | mNumFramesWritten = 0; |
| 888 | } |
Andreas Huber | 078cfcf | 2011-09-15 12:25:04 -0700 | [diff] [blame] | 889 | return false; |
Eric Laurent | 9b7d950 | 2011-03-21 11:49:00 -0700 | [diff] [blame] | 890 | } |
| 891 | |
Chong Zhang | 8163676 | 2015-04-21 09:33:47 -0700 | [diff] [blame] | 892 | // ignore 0-sized buffer which could be EOS marker with no data |
| 893 | if (entry->mOffset == 0 && entry->mBuffer->size() > 0) { |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 894 | int64_t mediaTimeUs; |
| 895 | CHECK(entry->mBuffer->meta()->findInt64("timeUs", &mediaTimeUs)); |
Andy Hung | a0b3971 | 2015-05-31 22:40:49 -0700 | [diff] [blame] | 896 | ALOGV("onDrainAudioQueue: rendering audio at media time %.2f secs", |
| 897 | mediaTimeUs / 1E6); |
Ronghua Wu | eecb780 | 2014-10-19 23:12:50 -0700 | [diff] [blame] | 898 | onNewAudioMediaTime(mediaTimeUs); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 899 | } |
| 900 | |
| 901 | size_t copy = entry->mBuffer->size() - entry->mOffset; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 902 | |
Wei Jia | 7d3f4df | 2015-03-03 15:28:00 -0800 | [diff] [blame] | 903 | ssize_t written = mAudioSink->write(entry->mBuffer->data() + entry->mOffset, |
| 904 | copy, false /* blocking */); |
Andy Hung | a31335a | 2014-08-20 17:37:59 -0700 | [diff] [blame] | 905 | if (written < 0) { |
Andy Hung | 202bce1 | 2014-12-03 11:47:36 -0800 | [diff] [blame] | 906 | // An error in AudioSink write. Perhaps the AudioSink was not properly opened. |
Wei Jia | 7d3f4df | 2015-03-03 15:28:00 -0800 | [diff] [blame] | 907 | if (written == WOULD_BLOCK) { |
Wei Jia | df80947 | 2015-06-09 11:21:13 -0700 | [diff] [blame] | 908 | ALOGV("AudioSink write would block when writing %zu bytes", copy); |
Wei Jia | 7d3f4df | 2015-03-03 15:28:00 -0800 | [diff] [blame] | 909 | } else { |
| 910 | ALOGE("AudioSink write error(%zd) when writing %zu bytes", written, copy); |
Ronghua Wu | 7665f58 | 2015-09-02 10:15:30 -0700 | [diff] [blame] | 911 | // This can only happen when AudioSink was opened with doNotReconnect flag set to |
| 912 | // true, in which case the NuPlayer will handle the reconnect. |
Ronghua Wu | faeb0f2 | 2015-05-21 12:20:21 -0700 | [diff] [blame] | 913 | notifyAudioTearDown(); |
Wei Jia | 7d3f4df | 2015-03-03 15:28:00 -0800 | [diff] [blame] | 914 | } |
Andy Hung | 202bce1 | 2014-12-03 11:47:36 -0800 | [diff] [blame] | 915 | break; |
Andy Hung | a31335a | 2014-08-20 17:37:59 -0700 | [diff] [blame] | 916 | } |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 917 | |
Andy Hung | a31335a | 2014-08-20 17:37:59 -0700 | [diff] [blame] | 918 | entry->mOffset += written; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 919 | if (entry->mOffset == entry->mBuffer->size()) { |
| 920 | entry->mNotifyConsumed->post(); |
| 921 | mAudioQueue.erase(mAudioQueue.begin()); |
Eric Laurent | 9b7d950 | 2011-03-21 11:49:00 -0700 | [diff] [blame] | 922 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 923 | entry = NULL; |
| 924 | } |
| 925 | |
Andy Hung | a31335a | 2014-08-20 17:37:59 -0700 | [diff] [blame] | 926 | size_t copiedFrames = written / mAudioSink->frameSize(); |
Andreas Huber | 078cfcf | 2011-09-15 12:25:04 -0700 | [diff] [blame] | 927 | mNumFramesWritten += copiedFrames; |
Lajos Molnar | cbaffcf | 2013-08-14 18:30:38 -0700 | [diff] [blame] | 928 | |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 929 | { |
| 930 | Mutex::Autolock autoLock(mLock); |
| 931 | notifyIfMediaRenderingStarted_l(); |
| 932 | } |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 933 | |
Andy Hung | a31335a | 2014-08-20 17:37:59 -0700 | [diff] [blame] | 934 | if (written != (ssize_t)copy) { |
| 935 | // A short count was received from AudioSink::write() |
| 936 | // |
Wei Jia | 7d3f4df | 2015-03-03 15:28:00 -0800 | [diff] [blame] | 937 | // AudioSink write is called in non-blocking mode. |
| 938 | // It may return with a short count when: |
Andy Hung | a31335a | 2014-08-20 17:37:59 -0700 | [diff] [blame] | 939 | // |
| 940 | // 1) Size to be copied is not a multiple of the frame size. We consider this fatal. |
Wei Jia | 7d3f4df | 2015-03-03 15:28:00 -0800 | [diff] [blame] | 941 | // 2) The data to be copied exceeds the available buffer in AudioSink. |
| 942 | // 3) An error occurs and data has been partially copied to the buffer in AudioSink. |
| 943 | // 4) AudioSink is an AudioCache for data retrieval, and the AudioCache is exceeded. |
Andy Hung | a31335a | 2014-08-20 17:37:59 -0700 | [diff] [blame] | 944 | |
| 945 | // (Case 1) |
| 946 | // Must be a multiple of the frame size. If it is not a multiple of a frame size, it |
| 947 | // needs to fail, as we should not carry over fractional frames between calls. |
| 948 | CHECK_EQ(copy % mAudioSink->frameSize(), 0); |
| 949 | |
Wei Jia | 7d3f4df | 2015-03-03 15:28:00 -0800 | [diff] [blame] | 950 | // (Case 2, 3, 4) |
Andy Hung | a31335a | 2014-08-20 17:37:59 -0700 | [diff] [blame] | 951 | // Return early to the caller. |
| 952 | // Beware of calling immediately again as this may busy-loop if you are not careful. |
Wei Jia | 7d3f4df | 2015-03-03 15:28:00 -0800 | [diff] [blame] | 953 | ALOGV("AudioSink write short frame count %zd < %zu", written, copy); |
Andy Hung | a31335a | 2014-08-20 17:37:59 -0700 | [diff] [blame] | 954 | break; |
| 955 | } |
| 956 | } |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 957 | int64_t maxTimeMedia; |
| 958 | { |
| 959 | Mutex::Autolock autoLock(mLock); |
| 960 | maxTimeMedia = |
| 961 | mAnchorTimeMediaUs + |
| 962 | (int64_t)(max((long long)mNumFramesWritten - mAnchorNumFramesWritten, 0LL) |
| 963 | * 1000LL * mAudioSink->msecsPerFrame()); |
| 964 | } |
| 965 | mMediaClock->updateMaxTimeMedia(maxTimeMedia); |
Lajos Molnar | f592671 | 2014-10-21 09:36:43 -0700 | [diff] [blame] | 966 | |
Andy Hung | 005e9d0 | 2015-05-31 23:16:07 -0700 | [diff] [blame] | 967 | // calculate whether we need to reschedule another write. |
| 968 | bool reschedule = !mAudioQueue.empty() |
| 969 | && (!mPaused |
| 970 | || prevFramesWritten != mNumFramesWritten); // permit pause to fill buffers |
| 971 | //ALOGD("reschedule:%d empty:%d mPaused:%d prevFramesWritten:%u mNumFramesWritten:%u", |
| 972 | // reschedule, mAudioQueue.empty(), mPaused, prevFramesWritten, mNumFramesWritten); |
| 973 | return reschedule; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 974 | } |
| 975 | |
Wei Jia | 9816016 | 2015-02-04 17:01:11 -0800 | [diff] [blame] | 976 | int64_t NuPlayer::Renderer::getDurationUsIfPlayedAtSampleRate(uint32_t numFrames) { |
| 977 | int32_t sampleRate = offloadingAudio() ? |
| 978 | mCurrentOffloadInfo.sample_rate : mCurrentPcmInfo.mSampleRate; |
Wei Jia | 4d7ac85 | 2015-08-31 18:33:14 -0700 | [diff] [blame] | 979 | if (sampleRate == 0) { |
| 980 | ALOGE("sampleRate is 0 in %s mode", offloadingAudio() ? "offload" : "non-offload"); |
| 981 | return 0; |
| 982 | } |
Wei Jia | 9816016 | 2015-02-04 17:01:11 -0800 | [diff] [blame] | 983 | // TODO: remove the (int32_t) casting below as it may overflow at 12.4 hours. |
| 984 | return (int64_t)((int32_t)numFrames * 1000000LL / sampleRate); |
| 985 | } |
| 986 | |
| 987 | // Calculate duration of pending samples if played at normal rate (i.e., 1.0). |
Lajos Molnar | 06ad152 | 2014-08-28 07:27:44 -0700 | [diff] [blame] | 988 | int64_t NuPlayer::Renderer::getPendingAudioPlayoutDurationUs(int64_t nowUs) { |
Wei Jia | 9816016 | 2015-02-04 17:01:11 -0800 | [diff] [blame] | 989 | int64_t writtenAudioDurationUs = getDurationUsIfPlayedAtSampleRate(mNumFramesWritten); |
Lajos Molnar | 06ad152 | 2014-08-28 07:27:44 -0700 | [diff] [blame] | 990 | return writtenAudioDurationUs - getPlayedOutAudioDurationUs(nowUs); |
Ronghua Wu | 5095d70 | 2014-08-27 12:05:48 -0700 | [diff] [blame] | 991 | } |
| 992 | |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 993 | int64_t NuPlayer::Renderer::getRealTimeUs(int64_t mediaTimeUs, int64_t nowUs) { |
Wei Jia | 9816016 | 2015-02-04 17:01:11 -0800 | [diff] [blame] | 994 | int64_t realUs; |
| 995 | if (mMediaClock->getRealTimeFor(mediaTimeUs, &realUs) != OK) { |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 996 | // If failed to get current position, e.g. due to audio clock is |
| 997 | // not ready, then just play out video immediately without delay. |
Ronghua Wu | eecb780 | 2014-10-19 23:12:50 -0700 | [diff] [blame] | 998 | return nowUs; |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 999 | } |
Wei Jia | 9816016 | 2015-02-04 17:01:11 -0800 | [diff] [blame] | 1000 | return realUs; |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 1001 | } |
| 1002 | |
Ronghua Wu | eecb780 | 2014-10-19 23:12:50 -0700 | [diff] [blame] | 1003 | void NuPlayer::Renderer::onNewAudioMediaTime(int64_t mediaTimeUs) { |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1004 | Mutex::Autolock autoLock(mLock); |
Ronghua Wu | eecb780 | 2014-10-19 23:12:50 -0700 | [diff] [blame] | 1005 | // TRICKY: vorbis decoder generates multiple frames with the same |
| 1006 | // timestamp, so only update on the first frame with a given timestamp |
| 1007 | if (mediaTimeUs == mAnchorTimeMediaUs) { |
| 1008 | return; |
| 1009 | } |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1010 | setAudioFirstAnchorTimeIfNeeded_l(mediaTimeUs); |
Ronghua Wu | eecb780 | 2014-10-19 23:12:50 -0700 | [diff] [blame] | 1011 | int64_t nowUs = ALooper::GetNowUs(); |
Wei Jia | 9816016 | 2015-02-04 17:01:11 -0800 | [diff] [blame] | 1012 | int64_t nowMediaUs = mediaTimeUs - getPendingAudioPlayoutDurationUs(nowUs); |
| 1013 | mMediaClock->updateAnchor(nowMediaUs, nowUs, mediaTimeUs); |
Wei Jia | 8edb3f8 | 2015-03-11 11:07:45 -0700 | [diff] [blame] | 1014 | mAnchorNumFramesWritten = mNumFramesWritten; |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1015 | mAnchorTimeMediaUs = mediaTimeUs; |
Ronghua Wu | eecb780 | 2014-10-19 23:12:50 -0700 | [diff] [blame] | 1016 | } |
| 1017 | |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1018 | // Called without mLock acquired. |
| 1019 | void NuPlayer::Renderer::postDrainVideoQueue() { |
Chong Zhang | fbe8bef | 2014-08-29 18:34:17 -0700 | [diff] [blame] | 1020 | if (mDrainVideoQueuePending |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1021 | || getSyncQueues() |
Chong Zhang | fbe8bef | 2014-08-29 18:34:17 -0700 | [diff] [blame] | 1022 | || (mPaused && mVideoSampleReceived)) { |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1023 | return; |
| 1024 | } |
| 1025 | |
| 1026 | if (mVideoQueue.empty()) { |
| 1027 | return; |
| 1028 | } |
| 1029 | |
| 1030 | QueueEntry &entry = *mVideoQueue.begin(); |
| 1031 | |
Lajos Molnar | 1d15ab5 | 2015-03-04 16:46:34 -0800 | [diff] [blame] | 1032 | sp<AMessage> msg = new AMessage(kWhatDrainVideoQueue, this); |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1033 | msg->setInt32("drainGeneration", getDrainGeneration(false /* audio */)); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1034 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1035 | if (entry.mBuffer == NULL) { |
| 1036 | // EOS doesn't carry a timestamp. |
Lajos Molnar | dc43dfa | 2014-05-07 15:33:04 -0700 | [diff] [blame] | 1037 | msg->post(); |
| 1038 | mDrainVideoQueuePending = true; |
| 1039 | return; |
| 1040 | } |
| 1041 | |
| 1042 | int64_t delayUs; |
| 1043 | int64_t nowUs = ALooper::GetNowUs(); |
| 1044 | int64_t realTimeUs; |
| 1045 | if (mFlags & FLAG_REAL_TIME) { |
Andreas Huber | d5e5623 | 2013-03-12 11:01:43 -0700 | [diff] [blame] | 1046 | int64_t mediaTimeUs; |
| 1047 | CHECK(entry.mBuffer->meta()->findInt64("timeUs", &mediaTimeUs)); |
Lajos Molnar | dc43dfa | 2014-05-07 15:33:04 -0700 | [diff] [blame] | 1048 | realTimeUs = mediaTimeUs; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1049 | } else { |
| 1050 | int64_t mediaTimeUs; |
| 1051 | CHECK(entry.mBuffer->meta()->findInt64("timeUs", &mediaTimeUs)); |
| 1052 | |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1053 | { |
| 1054 | Mutex::Autolock autoLock(mLock); |
| 1055 | if (mAnchorTimeMediaUs < 0) { |
| 1056 | mMediaClock->updateAnchor(mediaTimeUs, nowUs, mediaTimeUs); |
| 1057 | mAnchorTimeMediaUs = mediaTimeUs; |
| 1058 | realTimeUs = nowUs; |
| 1059 | } else { |
| 1060 | realTimeUs = getRealTimeUs(mediaTimeUs, nowUs); |
| 1061 | } |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1062 | } |
Lajos Molnar | f592671 | 2014-10-21 09:36:43 -0700 | [diff] [blame] | 1063 | if (!mHasAudio) { |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1064 | // smooth out videos >= 10fps |
| 1065 | mMediaClock->updateMaxTimeMedia(mediaTimeUs + 100000); |
Lajos Molnar | f592671 | 2014-10-21 09:36:43 -0700 | [diff] [blame] | 1066 | } |
Lajos Molnar | d592340 | 2014-10-20 17:47:54 -0700 | [diff] [blame] | 1067 | |
| 1068 | // Heuristics to handle situation when media time changed without a |
| 1069 | // discontinuity. If we have not drained an audio buffer that was |
| 1070 | // received after this buffer, repost in 10 msec. Otherwise repost |
| 1071 | // in 500 msec. |
| 1072 | delayUs = realTimeUs - nowUs; |
| 1073 | if (delayUs > 500000) { |
| 1074 | int64_t postDelayUs = 500000; |
| 1075 | if (mHasAudio && (mLastAudioBufferDrained - entry.mBufferOrdinal) <= 0) { |
| 1076 | postDelayUs = 10000; |
| 1077 | } |
| 1078 | msg->setWhat(kWhatPostDrainVideoQueue); |
| 1079 | msg->post(postDelayUs); |
| 1080 | mVideoScheduler->restart(); |
| 1081 | ALOGI("possible video time jump of %dms, retrying in %dms", |
| 1082 | (int)(delayUs / 1000), (int)(postDelayUs / 1000)); |
| 1083 | mDrainVideoQueuePending = true; |
| 1084 | return; |
| 1085 | } |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1086 | } |
| 1087 | |
Lajos Molnar | dc43dfa | 2014-05-07 15:33:04 -0700 | [diff] [blame] | 1088 | realTimeUs = mVideoScheduler->schedule(realTimeUs * 1000) / 1000; |
| 1089 | int64_t twoVsyncsUs = 2 * (mVideoScheduler->getVsyncPeriod() / 1000); |
| 1090 | |
| 1091 | delayUs = realTimeUs - nowUs; |
| 1092 | |
Lajos Molnar | 0952483 | 2014-07-17 14:29:51 -0700 | [diff] [blame] | 1093 | ALOGW_IF(delayUs > 500000, "unusually high delayUs: %" PRId64, delayUs); |
Lajos Molnar | dc43dfa | 2014-05-07 15:33:04 -0700 | [diff] [blame] | 1094 | // post 2 display refreshes before rendering is due |
| 1095 | msg->post(delayUs > twoVsyncsUs ? delayUs - twoVsyncsUs : 0); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1096 | |
| 1097 | mDrainVideoQueuePending = true; |
| 1098 | } |
| 1099 | |
| 1100 | void NuPlayer::Renderer::onDrainVideoQueue() { |
| 1101 | if (mVideoQueue.empty()) { |
| 1102 | return; |
| 1103 | } |
| 1104 | |
| 1105 | QueueEntry *entry = &*mVideoQueue.begin(); |
| 1106 | |
| 1107 | if (entry->mBuffer == NULL) { |
| 1108 | // EOS |
| 1109 | |
Andreas Huber | c92fd24 | 2011-08-16 13:48:44 -0700 | [diff] [blame] | 1110 | notifyEOS(false /* audio */, entry->mFinalResult); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1111 | |
| 1112 | mVideoQueue.erase(mVideoQueue.begin()); |
| 1113 | entry = NULL; |
Andreas Huber | 3fe6215 | 2011-09-16 15:09:22 -0700 | [diff] [blame] | 1114 | |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 1115 | setVideoLateByUs(0); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1116 | return; |
| 1117 | } |
| 1118 | |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 1119 | int64_t nowUs = -1; |
Andreas Huber | d5e5623 | 2013-03-12 11:01:43 -0700 | [diff] [blame] | 1120 | int64_t realTimeUs; |
Wei Jia | 2995dc7 | 2015-07-24 16:00:33 -0700 | [diff] [blame] | 1121 | int64_t mediaTimeUs = -1; |
Andreas Huber | d5e5623 | 2013-03-12 11:01:43 -0700 | [diff] [blame] | 1122 | if (mFlags & FLAG_REAL_TIME) { |
| 1123 | CHECK(entry->mBuffer->meta()->findInt64("timeUs", &realTimeUs)); |
| 1124 | } else { |
Andreas Huber | d5e5623 | 2013-03-12 11:01:43 -0700 | [diff] [blame] | 1125 | CHECK(entry->mBuffer->meta()->findInt64("timeUs", &mediaTimeUs)); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1126 | |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 1127 | nowUs = ALooper::GetNowUs(); |
| 1128 | realTimeUs = getRealTimeUs(mediaTimeUs, nowUs); |
Andreas Huber | d5e5623 | 2013-03-12 11:01:43 -0700 | [diff] [blame] | 1129 | } |
| 1130 | |
Chong Zhang | fbe8bef | 2014-08-29 18:34:17 -0700 | [diff] [blame] | 1131 | bool tooLate = false; |
Andreas Huber | 3fe6215 | 2011-09-16 15:09:22 -0700 | [diff] [blame] | 1132 | |
Chong Zhang | fbe8bef | 2014-08-29 18:34:17 -0700 | [diff] [blame] | 1133 | if (!mPaused) { |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 1134 | if (nowUs == -1) { |
| 1135 | nowUs = ALooper::GetNowUs(); |
| 1136 | } |
| 1137 | setVideoLateByUs(nowUs - realTimeUs); |
Chong Zhang | fbe8bef | 2014-08-29 18:34:17 -0700 | [diff] [blame] | 1138 | tooLate = (mVideoLateByUs > 40000); |
| 1139 | |
| 1140 | if (tooLate) { |
| 1141 | ALOGV("video late by %lld us (%.2f secs)", |
Lajos Molnar | 6d339f1 | 2015-04-17 16:15:53 -0700 | [diff] [blame] | 1142 | (long long)mVideoLateByUs, mVideoLateByUs / 1E6); |
Chong Zhang | fbe8bef | 2014-08-29 18:34:17 -0700 | [diff] [blame] | 1143 | } else { |
Wei Jia | 9816016 | 2015-02-04 17:01:11 -0800 | [diff] [blame] | 1144 | int64_t mediaUs = 0; |
| 1145 | mMediaClock->getMediaTime(realTimeUs, &mediaUs); |
Chong Zhang | fbe8bef | 2014-08-29 18:34:17 -0700 | [diff] [blame] | 1146 | ALOGV("rendering video at media time %.2f secs", |
| 1147 | (mFlags & FLAG_REAL_TIME ? realTimeUs : |
Wei Jia | 9816016 | 2015-02-04 17:01:11 -0800 | [diff] [blame] | 1148 | mediaUs) / 1E6); |
Wei Jia | 2995dc7 | 2015-07-24 16:00:33 -0700 | [diff] [blame] | 1149 | |
| 1150 | if (!(mFlags & FLAG_REAL_TIME) |
| 1151 | && mLastAudioMediaTimeUs != -1 |
| 1152 | && mediaTimeUs > mLastAudioMediaTimeUs) { |
| 1153 | // If audio ends before video, video continues to drive media clock. |
| 1154 | // Also smooth out videos >= 10fps. |
| 1155 | mMediaClock->updateMaxTimeMedia(mediaTimeUs + 100000); |
| 1156 | } |
Chong Zhang | fbe8bef | 2014-08-29 18:34:17 -0700 | [diff] [blame] | 1157 | } |
Andreas Huber | 078cfcf | 2011-09-15 12:25:04 -0700 | [diff] [blame] | 1158 | } else { |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 1159 | setVideoLateByUs(0); |
Ronghua Wu | eecb780 | 2014-10-19 23:12:50 -0700 | [diff] [blame] | 1160 | if (!mVideoSampleReceived && !mHasAudio) { |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 1161 | // This will ensure that the first frame after a flush won't be used as anchor |
| 1162 | // when renderer is in paused state, because resume can happen any time after seek. |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1163 | Mutex::Autolock autoLock(mLock); |
| 1164 | clearAnchorTime_l(); |
Wei Jia | 49966ff | 2014-10-08 18:44:45 -0700 | [diff] [blame] | 1165 | } |
Andreas Huber | 078cfcf | 2011-09-15 12:25:04 -0700 | [diff] [blame] | 1166 | } |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1167 | |
Lajos Molnar | dc43dfa | 2014-05-07 15:33:04 -0700 | [diff] [blame] | 1168 | entry->mNotifyConsumed->setInt64("timestampNs", realTimeUs * 1000ll); |
Glenn Kasten | 683525b | 2011-11-04 18:05:35 -0700 | [diff] [blame] | 1169 | entry->mNotifyConsumed->setInt32("render", !tooLate); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1170 | entry->mNotifyConsumed->post(); |
| 1171 | mVideoQueue.erase(mVideoQueue.begin()); |
| 1172 | entry = NULL; |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 1173 | |
Chong Zhang | fbe8bef | 2014-08-29 18:34:17 -0700 | [diff] [blame] | 1174 | mVideoSampleReceived = true; |
James Dong | f57b4ea | 2012-07-20 13:38:36 -0700 | [diff] [blame] | 1175 | |
Chong Zhang | fbe8bef | 2014-08-29 18:34:17 -0700 | [diff] [blame] | 1176 | if (!mPaused) { |
| 1177 | if (!mVideoRenderingStarted) { |
| 1178 | mVideoRenderingStarted = true; |
| 1179 | notifyVideoRenderingStart(); |
| 1180 | } |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1181 | Mutex::Autolock autoLock(mLock); |
| 1182 | notifyIfMediaRenderingStarted_l(); |
Chong Zhang | fbe8bef | 2014-08-29 18:34:17 -0700 | [diff] [blame] | 1183 | } |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1184 | } |
| 1185 | |
James Dong | f57b4ea | 2012-07-20 13:38:36 -0700 | [diff] [blame] | 1186 | void NuPlayer::Renderer::notifyVideoRenderingStart() { |
| 1187 | sp<AMessage> notify = mNotify->dup(); |
| 1188 | notify->setInt32("what", kWhatVideoRenderingStart); |
| 1189 | notify->post(); |
| 1190 | } |
| 1191 | |
Ronghua Wu | 5095d70 | 2014-08-27 12:05:48 -0700 | [diff] [blame] | 1192 | void NuPlayer::Renderer::notifyEOS(bool audio, status_t finalResult, int64_t delayUs) { |
Wei Jia | 7c8d0e0 | 2015-08-27 17:40:21 -0700 | [diff] [blame] | 1193 | if (audio && delayUs > 0) { |
| 1194 | sp<AMessage> msg = new AMessage(kWhatEOS, this); |
| 1195 | msg->setInt32("audioEOSGeneration", mAudioEOSGeneration); |
| 1196 | msg->setInt32("finalResult", finalResult); |
| 1197 | msg->post(delayUs); |
| 1198 | return; |
| 1199 | } |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1200 | sp<AMessage> notify = mNotify->dup(); |
| 1201 | notify->setInt32("what", kWhatEOS); |
| 1202 | notify->setInt32("audio", static_cast<int32_t>(audio)); |
Andreas Huber | c92fd24 | 2011-08-16 13:48:44 -0700 | [diff] [blame] | 1203 | notify->setInt32("finalResult", finalResult); |
Ronghua Wu | 5095d70 | 2014-08-27 12:05:48 -0700 | [diff] [blame] | 1204 | notify->post(delayUs); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1205 | } |
| 1206 | |
Ronghua Wu | faeb0f2 | 2015-05-21 12:20:21 -0700 | [diff] [blame] | 1207 | void NuPlayer::Renderer::notifyAudioTearDown() { |
| 1208 | (new AMessage(kWhatAudioTearDown, this))->post(); |
Wei Jia | 3a2956d | 2014-07-22 16:01:33 -0700 | [diff] [blame] | 1209 | } |
| 1210 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1211 | void NuPlayer::Renderer::onQueueBuffer(const sp<AMessage> &msg) { |
| 1212 | int32_t audio; |
| 1213 | CHECK(msg->findInt32("audio", &audio)); |
| 1214 | |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1215 | if (dropBufferIfStale(audio, msg)) { |
| 1216 | return; |
| 1217 | } |
| 1218 | |
| 1219 | if (audio) { |
| 1220 | mHasAudio = true; |
| 1221 | } else { |
| 1222 | mHasVideo = true; |
| 1223 | } |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 1224 | |
| 1225 | if (mHasVideo) { |
Lajos Molnar | dc43dfa | 2014-05-07 15:33:04 -0700 | [diff] [blame] | 1226 | if (mVideoScheduler == NULL) { |
| 1227 | mVideoScheduler = new VideoFrameScheduler(); |
| 1228 | mVideoScheduler->init(); |
| 1229 | } |
Andreas Huber | bc7f5b2 | 2011-01-21 10:15:23 -0800 | [diff] [blame] | 1230 | } |
| 1231 | |
Andreas Huber | 2d8bedd | 2012-02-21 14:38:23 -0800 | [diff] [blame] | 1232 | sp<ABuffer> buffer; |
| 1233 | CHECK(msg->findBuffer("buffer", &buffer)); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1234 | |
| 1235 | sp<AMessage> notifyConsumed; |
| 1236 | CHECK(msg->findMessage("notifyConsumed", ¬ifyConsumed)); |
| 1237 | |
| 1238 | QueueEntry entry; |
| 1239 | entry.mBuffer = buffer; |
| 1240 | entry.mNotifyConsumed = notifyConsumed; |
| 1241 | entry.mOffset = 0; |
| 1242 | entry.mFinalResult = OK; |
Lajos Molnar | d592340 | 2014-10-20 17:47:54 -0700 | [diff] [blame] | 1243 | entry.mBufferOrdinal = ++mTotalBuffersQueued; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1244 | |
| 1245 | if (audio) { |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1246 | Mutex::Autolock autoLock(mLock); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1247 | mAudioQueue.push_back(entry); |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 1248 | postDrainAudioQueue_l(); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1249 | } else { |
| 1250 | mVideoQueue.push_back(entry); |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1251 | postDrainVideoQueue(); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1252 | } |
| 1253 | |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1254 | Mutex::Autolock autoLock(mLock); |
Andreas Huber | cb67cd1 | 2011-08-26 16:02:19 -0700 | [diff] [blame] | 1255 | if (!mSyncQueues || mAudioQueue.empty() || mVideoQueue.empty()) { |
| 1256 | return; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1257 | } |
Andreas Huber | cb67cd1 | 2011-08-26 16:02:19 -0700 | [diff] [blame] | 1258 | |
| 1259 | sp<ABuffer> firstAudioBuffer = (*mAudioQueue.begin()).mBuffer; |
| 1260 | sp<ABuffer> firstVideoBuffer = (*mVideoQueue.begin()).mBuffer; |
| 1261 | |
| 1262 | if (firstAudioBuffer == NULL || firstVideoBuffer == NULL) { |
| 1263 | // EOS signalled on either queue. |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 1264 | syncQueuesDone_l(); |
Andreas Huber | cb67cd1 | 2011-08-26 16:02:19 -0700 | [diff] [blame] | 1265 | return; |
| 1266 | } |
| 1267 | |
| 1268 | int64_t firstAudioTimeUs; |
| 1269 | int64_t firstVideoTimeUs; |
| 1270 | CHECK(firstAudioBuffer->meta() |
| 1271 | ->findInt64("timeUs", &firstAudioTimeUs)); |
| 1272 | CHECK(firstVideoBuffer->meta() |
| 1273 | ->findInt64("timeUs", &firstVideoTimeUs)); |
| 1274 | |
| 1275 | int64_t diff = firstVideoTimeUs - firstAudioTimeUs; |
| 1276 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1277 | ALOGV("queueDiff = %.2f secs", diff / 1E6); |
Andreas Huber | cb67cd1 | 2011-08-26 16:02:19 -0700 | [diff] [blame] | 1278 | |
| 1279 | if (diff > 100000ll) { |
| 1280 | // Audio data starts More than 0.1 secs before video. |
| 1281 | // Drop some audio. |
| 1282 | |
| 1283 | (*mAudioQueue.begin()).mNotifyConsumed->post(); |
| 1284 | mAudioQueue.erase(mAudioQueue.begin()); |
| 1285 | return; |
| 1286 | } |
| 1287 | |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 1288 | syncQueuesDone_l(); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1289 | } |
| 1290 | |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 1291 | void NuPlayer::Renderer::syncQueuesDone_l() { |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1292 | if (!mSyncQueues) { |
| 1293 | return; |
| 1294 | } |
| 1295 | |
| 1296 | mSyncQueues = false; |
| 1297 | |
| 1298 | if (!mAudioQueue.empty()) { |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 1299 | postDrainAudioQueue_l(); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1300 | } |
| 1301 | |
| 1302 | if (!mVideoQueue.empty()) { |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1303 | mLock.unlock(); |
| 1304 | postDrainVideoQueue(); |
| 1305 | mLock.lock(); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1306 | } |
| 1307 | } |
| 1308 | |
| 1309 | void NuPlayer::Renderer::onQueueEOS(const sp<AMessage> &msg) { |
| 1310 | int32_t audio; |
| 1311 | CHECK(msg->findInt32("audio", &audio)); |
| 1312 | |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1313 | if (dropBufferIfStale(audio, msg)) { |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1314 | return; |
| 1315 | } |
| 1316 | |
| 1317 | int32_t finalResult; |
| 1318 | CHECK(msg->findInt32("finalResult", &finalResult)); |
| 1319 | |
| 1320 | QueueEntry entry; |
| 1321 | entry.mOffset = 0; |
| 1322 | entry.mFinalResult = finalResult; |
| 1323 | |
| 1324 | if (audio) { |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1325 | Mutex::Autolock autoLock(mLock); |
Roger Jönsson | b50e83e | 2013-01-21 16:26:41 +0100 | [diff] [blame] | 1326 | if (mAudioQueue.empty() && mSyncQueues) { |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 1327 | syncQueuesDone_l(); |
Roger Jönsson | b50e83e | 2013-01-21 16:26:41 +0100 | [diff] [blame] | 1328 | } |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1329 | mAudioQueue.push_back(entry); |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 1330 | postDrainAudioQueue_l(); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1331 | } else { |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1332 | if (mVideoQueue.empty() && getSyncQueues()) { |
| 1333 | Mutex::Autolock autoLock(mLock); |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 1334 | syncQueuesDone_l(); |
Roger Jönsson | b50e83e | 2013-01-21 16:26:41 +0100 | [diff] [blame] | 1335 | } |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1336 | mVideoQueue.push_back(entry); |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1337 | postDrainVideoQueue(); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1338 | } |
| 1339 | } |
| 1340 | |
| 1341 | void NuPlayer::Renderer::onFlush(const sp<AMessage> &msg) { |
Chong Zhang | 7137ec7 | 2014-11-12 16:41:05 -0800 | [diff] [blame] | 1342 | int32_t audio, notifyComplete; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1343 | CHECK(msg->findInt32("audio", &audio)); |
| 1344 | |
Wei Jia | 28a8a9f | 2014-08-18 11:29:50 -0700 | [diff] [blame] | 1345 | { |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1346 | Mutex::Autolock autoLock(mLock); |
Wei Jia | 28a8a9f | 2014-08-18 11:29:50 -0700 | [diff] [blame] | 1347 | if (audio) { |
Chong Zhang | 7137ec7 | 2014-11-12 16:41:05 -0800 | [diff] [blame] | 1348 | notifyComplete = mNotifyCompleteAudio; |
| 1349 | mNotifyCompleteAudio = false; |
Wei Jia | 2995dc7 | 2015-07-24 16:00:33 -0700 | [diff] [blame] | 1350 | mLastAudioMediaTimeUs = -1; |
Wei Jia | 28a8a9f | 2014-08-18 11:29:50 -0700 | [diff] [blame] | 1351 | } else { |
Chong Zhang | 7137ec7 | 2014-11-12 16:41:05 -0800 | [diff] [blame] | 1352 | notifyComplete = mNotifyCompleteVideo; |
| 1353 | mNotifyCompleteVideo = false; |
Wei Jia | 28a8a9f | 2014-08-18 11:29:50 -0700 | [diff] [blame] | 1354 | } |
Wei Jia | 28a8a9f | 2014-08-18 11:29:50 -0700 | [diff] [blame] | 1355 | |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1356 | // If we're currently syncing the queues, i.e. dropping audio while |
| 1357 | // aligning the first audio/video buffer times and only one of the |
| 1358 | // two queues has data, we may starve that queue by not requesting |
| 1359 | // more buffers from the decoder. If the other source then encounters |
| 1360 | // a discontinuity that leads to flushing, we'll never find the |
| 1361 | // corresponding discontinuity on the other queue. |
| 1362 | // Therefore we'll stop syncing the queues if at least one of them |
| 1363 | // is flushed. |
| 1364 | syncQueuesDone_l(); |
| 1365 | clearAnchorTime_l(); |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 1366 | } |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1367 | |
Lajos Molnar | cbaffcf | 2013-08-14 18:30:38 -0700 | [diff] [blame] | 1368 | ALOGV("flushing %s", audio ? "audio" : "video"); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1369 | if (audio) { |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 1370 | { |
| 1371 | Mutex::Autolock autoLock(mLock); |
| 1372 | flushQueue(&mAudioQueue); |
Wei Jia | 28a8a9f | 2014-08-18 11:29:50 -0700 | [diff] [blame] | 1373 | |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1374 | ++mAudioDrainGeneration; |
Wei Jia | 7c8d0e0 | 2015-08-27 17:40:21 -0700 | [diff] [blame] | 1375 | ++mAudioEOSGeneration; |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1376 | prepareForMediaRenderingStart_l(); |
Wei Jia | 28a8a9f | 2014-08-18 11:29:50 -0700 | [diff] [blame] | 1377 | |
Andy Hung | a0b3971 | 2015-05-31 22:40:49 -0700 | [diff] [blame] | 1378 | // the frame count will be reset after flush. |
| 1379 | clearAudioFirstAnchorTime_l(); |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 1380 | } |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1381 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1382 | mDrainAudioQueuePending = false; |
Lajos Molnar | cbaffcf | 2013-08-14 18:30:38 -0700 | [diff] [blame] | 1383 | |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 1384 | if (offloadingAudio()) { |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 1385 | mAudioSink->pause(); |
| 1386 | mAudioSink->flush(); |
Andy Hung | 85e4814 | 2015-05-31 23:04:15 -0700 | [diff] [blame] | 1387 | if (!mPaused) { |
| 1388 | mAudioSink->start(); |
| 1389 | } |
Wei Jia | 9e7ed33 | 2015-05-01 16:35:43 -0700 | [diff] [blame] | 1390 | } else { |
| 1391 | mAudioSink->pause(); |
| 1392 | mAudioSink->flush(); |
| 1393 | // Call stop() to signal to the AudioSink to completely fill the |
| 1394 | // internal buffer before resuming playback. |
Andy Hung | b03dcb3 | 2015-08-27 16:18:59 -0700 | [diff] [blame] | 1395 | // FIXME: this is ignored after flush(). |
Wei Jia | 9e7ed33 | 2015-05-01 16:35:43 -0700 | [diff] [blame] | 1396 | mAudioSink->stop(); |
Andy Hung | b03dcb3 | 2015-08-27 16:18:59 -0700 | [diff] [blame] | 1397 | if (mPaused) { |
| 1398 | // Race condition: if renderer is paused and audio sink is stopped, |
| 1399 | // we need to make sure that the audio track buffer fully drains |
| 1400 | // before delivering data. |
| 1401 | // FIXME: remove this if we can detect if stop() is complete. |
| 1402 | const int delayUs = 2 * 50 * 1000; // (2 full mixer thread cycles at 50ms) |
| 1403 | mPauseDrainAudioAllowedUs = ALooper::GetNowUs() + delayUs; |
| 1404 | } else { |
Wei Jia | 9e7ed33 | 2015-05-01 16:35:43 -0700 | [diff] [blame] | 1405 | mAudioSink->start(); |
| 1406 | } |
| 1407 | mNumFramesWritten = 0; |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 1408 | } |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1409 | } else { |
| 1410 | flushQueue(&mVideoQueue); |
| 1411 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1412 | mDrainVideoQueuePending = false; |
Lajos Molnar | cbaffcf | 2013-08-14 18:30:38 -0700 | [diff] [blame] | 1413 | |
Lajos Molnar | c851b5d | 2014-09-18 14:14:29 -0700 | [diff] [blame] | 1414 | if (mVideoScheduler != NULL) { |
| 1415 | mVideoScheduler->restart(); |
| 1416 | } |
| 1417 | |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1418 | Mutex::Autolock autoLock(mLock); |
| 1419 | ++mVideoDrainGeneration; |
| 1420 | prepareForMediaRenderingStart_l(); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1421 | } |
| 1422 | |
Chong Zhang | fbe8bef | 2014-08-29 18:34:17 -0700 | [diff] [blame] | 1423 | mVideoSampleReceived = false; |
Chong Zhang | 7137ec7 | 2014-11-12 16:41:05 -0800 | [diff] [blame] | 1424 | |
| 1425 | if (notifyComplete) { |
| 1426 | notifyFlushComplete(audio); |
| 1427 | } |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1428 | } |
| 1429 | |
| 1430 | void NuPlayer::Renderer::flushQueue(List<QueueEntry> *queue) { |
| 1431 | while (!queue->empty()) { |
| 1432 | QueueEntry *entry = &*queue->begin(); |
| 1433 | |
| 1434 | if (entry->mBuffer != NULL) { |
| 1435 | entry->mNotifyConsumed->post(); |
| 1436 | } |
| 1437 | |
| 1438 | queue->erase(queue->begin()); |
| 1439 | entry = NULL; |
| 1440 | } |
| 1441 | } |
| 1442 | |
| 1443 | void NuPlayer::Renderer::notifyFlushComplete(bool audio) { |
| 1444 | sp<AMessage> notify = mNotify->dup(); |
| 1445 | notify->setInt32("what", kWhatFlushComplete); |
| 1446 | notify->setInt32("audio", static_cast<int32_t>(audio)); |
| 1447 | notify->post(); |
| 1448 | } |
| 1449 | |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1450 | bool NuPlayer::Renderer::dropBufferIfStale( |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1451 | bool audio, const sp<AMessage> &msg) { |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1452 | int32_t queueGeneration; |
| 1453 | CHECK(msg->findInt32("queueGeneration", &queueGeneration)); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1454 | |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1455 | if (queueGeneration == getQueueGeneration(audio)) { |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1456 | return false; |
| 1457 | } |
| 1458 | |
| 1459 | sp<AMessage> notifyConsumed; |
| 1460 | if (msg->findMessage("notifyConsumed", ¬ifyConsumed)) { |
| 1461 | notifyConsumed->post(); |
| 1462 | } |
| 1463 | |
| 1464 | return true; |
| 1465 | } |
| 1466 | |
Andreas Huber | 3831a06 | 2010-12-21 10:22:33 -0800 | [diff] [blame] | 1467 | void NuPlayer::Renderer::onAudioSinkChanged() { |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 1468 | if (offloadingAudio()) { |
| 1469 | return; |
| 1470 | } |
Andreas Huber | 3831a06 | 2010-12-21 10:22:33 -0800 | [diff] [blame] | 1471 | CHECK(!mDrainAudioQueuePending); |
| 1472 | mNumFramesWritten = 0; |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1473 | { |
| 1474 | Mutex::Autolock autoLock(mLock); |
| 1475 | mAnchorNumFramesWritten = -1; |
| 1476 | } |
Marco Nelissen | 4110c10 | 2012-03-29 09:31:28 -0700 | [diff] [blame] | 1477 | uint32_t written; |
| 1478 | if (mAudioSink->getFramesWritten(&written) == OK) { |
| 1479 | mNumFramesWritten = written; |
| 1480 | } |
Andreas Huber | 3831a06 | 2010-12-21 10:22:33 -0800 | [diff] [blame] | 1481 | } |
| 1482 | |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 1483 | void NuPlayer::Renderer::onDisableOffloadAudio() { |
| 1484 | Mutex::Autolock autoLock(mLock); |
| 1485 | mFlags &= ~FLAG_OFFLOAD_AUDIO; |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1486 | ++mAudioDrainGeneration; |
Robert Shih | e1d7019 | 2015-07-23 17:54:13 -0700 | [diff] [blame] | 1487 | if (mAudioRenderingStartGeneration != -1) { |
| 1488 | prepareForMediaRenderingStart_l(); |
| 1489 | } |
Wei Jia | bc2fb72 | 2014-07-08 16:37:57 -0700 | [diff] [blame] | 1490 | } |
| 1491 | |
Ronghua Wu | a10fd23 | 2014-11-06 16:15:20 -0800 | [diff] [blame] | 1492 | void NuPlayer::Renderer::onEnableOffloadAudio() { |
| 1493 | Mutex::Autolock autoLock(mLock); |
| 1494 | mFlags |= FLAG_OFFLOAD_AUDIO; |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1495 | ++mAudioDrainGeneration; |
Robert Shih | e1d7019 | 2015-07-23 17:54:13 -0700 | [diff] [blame] | 1496 | if (mAudioRenderingStartGeneration != -1) { |
| 1497 | prepareForMediaRenderingStart_l(); |
| 1498 | } |
Ronghua Wu | a10fd23 | 2014-11-06 16:15:20 -0800 | [diff] [blame] | 1499 | } |
| 1500 | |
Andreas Huber | b408222 | 2011-01-20 15:23:04 -0800 | [diff] [blame] | 1501 | void NuPlayer::Renderer::onPause() { |
Rachad | 8592dbb | 2014-09-09 13:10:28 -0700 | [diff] [blame] | 1502 | if (mPaused) { |
Rachad | 8592dbb | 2014-09-09 13:10:28 -0700 | [diff] [blame] | 1503 | return; |
| 1504 | } |
Lajos Molnar | 6d339f1 | 2015-04-17 16:15:53 -0700 | [diff] [blame] | 1505 | |
Wei Jia | 28a8a9f | 2014-08-18 11:29:50 -0700 | [diff] [blame] | 1506 | { |
| 1507 | Mutex::Autolock autoLock(mLock); |
Andy Hung | 005e9d0 | 2015-05-31 23:16:07 -0700 | [diff] [blame] | 1508 | // we do not increment audio drain generation so that we fill audio buffer during pause. |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1509 | ++mVideoDrainGeneration; |
| 1510 | prepareForMediaRenderingStart_l(); |
Wei Jia | 73ddd21 | 2014-08-29 16:33:49 -0700 | [diff] [blame] | 1511 | mPaused = true; |
Wei Jia | 9816016 | 2015-02-04 17:01:11 -0800 | [diff] [blame] | 1512 | mMediaClock->setPlaybackRate(0.0); |
Wei Jia | 28a8a9f | 2014-08-18 11:29:50 -0700 | [diff] [blame] | 1513 | } |
| 1514 | |
Andreas Huber | b408222 | 2011-01-20 15:23:04 -0800 | [diff] [blame] | 1515 | mDrainAudioQueuePending = false; |
Andreas Huber | b408222 | 2011-01-20 15:23:04 -0800 | [diff] [blame] | 1516 | mDrainVideoQueuePending = false; |
Lajos Molnar | cbaffcf | 2013-08-14 18:30:38 -0700 | [diff] [blame] | 1517 | |
Andreas Huber | b408222 | 2011-01-20 15:23:04 -0800 | [diff] [blame] | 1518 | if (mHasAudio) { |
| 1519 | mAudioSink->pause(); |
Ronghua Wu | f5b1db1 | 2014-09-09 10:11:08 -0700 | [diff] [blame] | 1520 | startAudioOffloadPauseTimeout(); |
Andreas Huber | b408222 | 2011-01-20 15:23:04 -0800 | [diff] [blame] | 1521 | } |
| 1522 | |
Lajos Molnar | 6d339f1 | 2015-04-17 16:15:53 -0700 | [diff] [blame] | 1523 | ALOGV("now paused audio queue has %zu entries, video has %zu entries", |
Andreas Huber | ea9d51b | 2011-11-30 09:53:40 -0800 | [diff] [blame] | 1524 | mAudioQueue.size(), mVideoQueue.size()); |
Andreas Huber | b408222 | 2011-01-20 15:23:04 -0800 | [diff] [blame] | 1525 | } |
| 1526 | |
| 1527 | void NuPlayer::Renderer::onResume() { |
Andreas Huber | b58ce9f | 2011-11-28 16:27:35 -0800 | [diff] [blame] | 1528 | if (!mPaused) { |
| 1529 | return; |
| 1530 | } |
Andreas Huber | b408222 | 2011-01-20 15:23:04 -0800 | [diff] [blame] | 1531 | |
| 1532 | if (mHasAudio) { |
Ronghua Wu | f5b1db1 | 2014-09-09 10:11:08 -0700 | [diff] [blame] | 1533 | cancelAudioOffloadPauseTimeout(); |
Eric Laurent | 97c9f4f | 2015-08-11 18:04:14 -0700 | [diff] [blame] | 1534 | status_t err = mAudioSink->start(); |
| 1535 | if (err != OK) { |
| 1536 | notifyAudioTearDown(); |
| 1537 | } |
Andreas Huber | b408222 | 2011-01-20 15:23:04 -0800 | [diff] [blame] | 1538 | } |
| 1539 | |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1540 | { |
| 1541 | Mutex::Autolock autoLock(mLock); |
| 1542 | mPaused = false; |
Andy Hung | b12ea0b | 2015-09-03 15:13:01 -0700 | [diff] [blame^] | 1543 | // rendering started message may have been delayed if we were paused. |
| 1544 | if (mRenderingDataDelivered) { |
| 1545 | notifyIfMediaRenderingStarted_l(); |
| 1546 | } |
Lajos Molnar | 3a474aa | 2015-04-24 17:10:07 -0700 | [diff] [blame] | 1547 | // configure audiosink as we did not do it when pausing |
Wei Jia | 27ea08e | 2015-05-12 14:50:35 -0700 | [diff] [blame] | 1548 | if (mAudioSink != NULL && mAudioSink->ready()) { |
Lajos Molnar | 3a474aa | 2015-04-24 17:10:07 -0700 | [diff] [blame] | 1549 | mAudioSink->setPlaybackRate(mPlaybackSettings); |
| 1550 | } |
| 1551 | |
Wei Jia | 9816016 | 2015-02-04 17:01:11 -0800 | [diff] [blame] | 1552 | mMediaClock->setPlaybackRate(mPlaybackRate); |
Andreas Huber | b408222 | 2011-01-20 15:23:04 -0800 | [diff] [blame] | 1553 | |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1554 | if (!mAudioQueue.empty()) { |
| 1555 | postDrainAudioQueue_l(); |
| 1556 | } |
Andreas Huber | b408222 | 2011-01-20 15:23:04 -0800 | [diff] [blame] | 1557 | } |
| 1558 | |
| 1559 | if (!mVideoQueue.empty()) { |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1560 | postDrainVideoQueue(); |
Andreas Huber | b408222 | 2011-01-20 15:23:04 -0800 | [diff] [blame] | 1561 | } |
| 1562 | } |
| 1563 | |
Lajos Molnar | c851b5d | 2014-09-18 14:14:29 -0700 | [diff] [blame] | 1564 | void NuPlayer::Renderer::onSetVideoFrameRate(float fps) { |
| 1565 | if (mVideoScheduler == NULL) { |
| 1566 | mVideoScheduler = new VideoFrameScheduler(); |
| 1567 | } |
| 1568 | mVideoScheduler->init(fps); |
| 1569 | } |
| 1570 | |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1571 | int32_t NuPlayer::Renderer::getQueueGeneration(bool audio) { |
| 1572 | Mutex::Autolock autoLock(mLock); |
| 1573 | return (audio ? mAudioQueueGeneration : mVideoQueueGeneration); |
| 1574 | } |
| 1575 | |
| 1576 | int32_t NuPlayer::Renderer::getDrainGeneration(bool audio) { |
| 1577 | Mutex::Autolock autoLock(mLock); |
| 1578 | return (audio ? mAudioDrainGeneration : mVideoDrainGeneration); |
| 1579 | } |
| 1580 | |
| 1581 | bool NuPlayer::Renderer::getSyncQueues() { |
| 1582 | Mutex::Autolock autoLock(mLock); |
| 1583 | return mSyncQueues; |
| 1584 | } |
| 1585 | |
Andy Hung | 09e0c36 | 2014-09-12 15:12:16 -0700 | [diff] [blame] | 1586 | // TODO: Remove unnecessary calls to getPlayedOutAudioDurationUs() |
| 1587 | // as it acquires locks and may query the audio driver. |
| 1588 | // |
Andy Hung | 09e0c36 | 2014-09-12 15:12:16 -0700 | [diff] [blame] | 1589 | // Some calls could conceivably retrieve extrapolated data instead of |
| 1590 | // accessing getTimestamp() or getPosition() every time a data buffer with |
| 1591 | // a media time is received. |
| 1592 | // |
Wei Jia | 9816016 | 2015-02-04 17:01:11 -0800 | [diff] [blame] | 1593 | // Calculate duration of played samples if played at normal rate (i.e., 1.0). |
Lajos Molnar | 06ad152 | 2014-08-28 07:27:44 -0700 | [diff] [blame] | 1594 | int64_t NuPlayer::Renderer::getPlayedOutAudioDurationUs(int64_t nowUs) { |
Wei Jia | 3a2956d | 2014-07-22 16:01:33 -0700 | [diff] [blame] | 1595 | uint32_t numFramesPlayed; |
Lajos Molnar | 06ad152 | 2014-08-28 07:27:44 -0700 | [diff] [blame] | 1596 | int64_t numFramesPlayedAt; |
| 1597 | AudioTimestamp ts; |
Andy Hung | 09e0c36 | 2014-09-12 15:12:16 -0700 | [diff] [blame] | 1598 | static const int64_t kStaleTimestamp100ms = 100000; |
| 1599 | |
Lajos Molnar | 06ad152 | 2014-08-28 07:27:44 -0700 | [diff] [blame] | 1600 | status_t res = mAudioSink->getTimestamp(ts); |
Andy Hung | 09e0c36 | 2014-09-12 15:12:16 -0700 | [diff] [blame] | 1601 | if (res == OK) { // case 1: mixing audio tracks and offloaded tracks. |
Lajos Molnar | 06ad152 | 2014-08-28 07:27:44 -0700 | [diff] [blame] | 1602 | numFramesPlayed = ts.mPosition; |
| 1603 | numFramesPlayedAt = |
| 1604 | ts.mTime.tv_sec * 1000000LL + ts.mTime.tv_nsec / 1000; |
Andy Hung | 09e0c36 | 2014-09-12 15:12:16 -0700 | [diff] [blame] | 1605 | const int64_t timestampAge = nowUs - numFramesPlayedAt; |
| 1606 | if (timestampAge > kStaleTimestamp100ms) { |
| 1607 | // This is an audio FIXME. |
| 1608 | // getTimestamp returns a timestamp which may come from audio mixing threads. |
| 1609 | // After pausing, the MixerThread may go idle, thus the mTime estimate may |
| 1610 | // become stale. Assuming that the MixerThread runs 20ms, with FastMixer at 5ms, |
| 1611 | // the max latency should be about 25ms with an average around 12ms (to be verified). |
| 1612 | // For safety we use 100ms. |
Andy Hung | 2abde2c | 2014-09-30 14:40:32 -0700 | [diff] [blame] | 1613 | ALOGV("getTimestamp: returned stale timestamp nowUs(%lld) numFramesPlayedAt(%lld)", |
Andy Hung | 09e0c36 | 2014-09-12 15:12:16 -0700 | [diff] [blame] | 1614 | (long long)nowUs, (long long)numFramesPlayedAt); |
| 1615 | numFramesPlayedAt = nowUs - kStaleTimestamp100ms; |
| 1616 | } |
| 1617 | //ALOGD("getTimestamp: OK %d %lld", numFramesPlayed, (long long)numFramesPlayedAt); |
| 1618 | } else if (res == WOULD_BLOCK) { // case 2: transitory state on start of a new track |
| 1619 | numFramesPlayed = 0; |
| 1620 | numFramesPlayedAt = nowUs; |
| 1621 | //ALOGD("getTimestamp: WOULD_BLOCK %d %lld", |
| 1622 | // numFramesPlayed, (long long)numFramesPlayedAt); |
| 1623 | } else { // case 3: transitory at new track or audio fast tracks. |
Lajos Molnar | 06ad152 | 2014-08-28 07:27:44 -0700 | [diff] [blame] | 1624 | res = mAudioSink->getPosition(&numFramesPlayed); |
| 1625 | CHECK_EQ(res, (status_t)OK); |
| 1626 | numFramesPlayedAt = nowUs; |
| 1627 | numFramesPlayedAt += 1000LL * mAudioSink->latency() / 2; /* XXX */ |
Lajos Molnar | 6d339f1 | 2015-04-17 16:15:53 -0700 | [diff] [blame] | 1628 | //ALOGD("getPosition: %u %lld", numFramesPlayed, (long long)numFramesPlayedAt); |
Lajos Molnar | 06ad152 | 2014-08-28 07:27:44 -0700 | [diff] [blame] | 1629 | } |
Andy Hung | 09e0c36 | 2014-09-12 15:12:16 -0700 | [diff] [blame] | 1630 | |
Andy Hung | 09e0c36 | 2014-09-12 15:12:16 -0700 | [diff] [blame] | 1631 | //CHECK_EQ(numFramesPlayed & (1 << 31), 0); // can't be negative until 12.4 hrs, test |
Wei Jia | 9816016 | 2015-02-04 17:01:11 -0800 | [diff] [blame] | 1632 | int64_t durationUs = getDurationUsIfPlayedAtSampleRate(numFramesPlayed) |
Lajos Molnar | 06ad152 | 2014-08-28 07:27:44 -0700 | [diff] [blame] | 1633 | + nowUs - numFramesPlayedAt; |
Andy Hung | 09e0c36 | 2014-09-12 15:12:16 -0700 | [diff] [blame] | 1634 | if (durationUs < 0) { |
| 1635 | // Occurs when numFramesPlayed position is very small and the following: |
| 1636 | // (1) In case 1, the time nowUs is computed before getTimestamp() is called and |
| 1637 | // numFramesPlayedAt is greater than nowUs by time more than numFramesPlayed. |
| 1638 | // (2) In case 3, using getPosition and adding mAudioSink->latency() to |
| 1639 | // numFramesPlayedAt, by a time amount greater than numFramesPlayed. |
| 1640 | // |
| 1641 | // Both of these are transitory conditions. |
Andy Hung | 2abde2c | 2014-09-30 14:40:32 -0700 | [diff] [blame] | 1642 | ALOGV("getPlayedOutAudioDurationUs: negative duration %lld set to zero", (long long)durationUs); |
Andy Hung | 09e0c36 | 2014-09-12 15:12:16 -0700 | [diff] [blame] | 1643 | durationUs = 0; |
| 1644 | } |
| 1645 | ALOGV("getPlayedOutAudioDurationUs(%lld) nowUs(%lld) frames(%u) framesAt(%lld)", |
| 1646 | (long long)durationUs, (long long)nowUs, numFramesPlayed, (long long)numFramesPlayedAt); |
| 1647 | return durationUs; |
Lajos Molnar | 06ad152 | 2014-08-28 07:27:44 -0700 | [diff] [blame] | 1648 | } |
Wei Jia | 3a2956d | 2014-07-22 16:01:33 -0700 | [diff] [blame] | 1649 | |
Ronghua Wu | faeb0f2 | 2015-05-21 12:20:21 -0700 | [diff] [blame] | 1650 | void NuPlayer::Renderer::onAudioTearDown(AudioTearDownReason reason) { |
| 1651 | if (mAudioTornDown) { |
Ronghua Wu | f5b1db1 | 2014-09-09 10:11:08 -0700 | [diff] [blame] | 1652 | return; |
| 1653 | } |
Ronghua Wu | faeb0f2 | 2015-05-21 12:20:21 -0700 | [diff] [blame] | 1654 | mAudioTornDown = true; |
Ronghua Wu | f5b1db1 | 2014-09-09 10:11:08 -0700 | [diff] [blame] | 1655 | |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame] | 1656 | int64_t currentPositionUs; |
Robert Shih | 1a5c859 | 2015-08-04 18:07:44 -0700 | [diff] [blame] | 1657 | sp<AMessage> notify = mNotify->dup(); |
| 1658 | if (getCurrentPosition(¤tPositionUs) == OK) { |
| 1659 | notify->setInt64("positionUs", currentPositionUs); |
Wei Jia | 28a8a9f | 2014-08-18 11:29:50 -0700 | [diff] [blame] | 1660 | } |
Lajos Molnar | 06ad152 | 2014-08-28 07:27:44 -0700 | [diff] [blame] | 1661 | |
Wei Jia | 3a2956d | 2014-07-22 16:01:33 -0700 | [diff] [blame] | 1662 | mAudioSink->stop(); |
| 1663 | mAudioSink->flush(); |
| 1664 | |
Ronghua Wu | faeb0f2 | 2015-05-21 12:20:21 -0700 | [diff] [blame] | 1665 | notify->setInt32("what", kWhatAudioTearDown); |
Ronghua Wu | 0852917 | 2014-10-02 16:55:52 -0700 | [diff] [blame] | 1666 | notify->setInt32("reason", reason); |
Wei Jia | 3a2956d | 2014-07-22 16:01:33 -0700 | [diff] [blame] | 1667 | notify->post(); |
| 1668 | } |
| 1669 | |
Ronghua Wu | f5b1db1 | 2014-09-09 10:11:08 -0700 | [diff] [blame] | 1670 | void NuPlayer::Renderer::startAudioOffloadPauseTimeout() { |
| 1671 | if (offloadingAudio()) { |
Weiyin Jiang | 35d5af1 | 2015-01-28 16:14:02 +0800 | [diff] [blame] | 1672 | mWakeLock->acquire(); |
Lajos Molnar | 1d15ab5 | 2015-03-04 16:46:34 -0800 | [diff] [blame] | 1673 | sp<AMessage> msg = new AMessage(kWhatAudioOffloadPauseTimeout, this); |
Wei Jia | 7b15cb3 | 2015-02-03 17:46:06 -0800 | [diff] [blame] | 1674 | msg->setInt32("drainGeneration", mAudioOffloadPauseTimeoutGeneration); |
Ronghua Wu | f5b1db1 | 2014-09-09 10:11:08 -0700 | [diff] [blame] | 1675 | msg->post(kOffloadPauseMaxUs); |
| 1676 | } |
| 1677 | } |
| 1678 | |
| 1679 | void NuPlayer::Renderer::cancelAudioOffloadPauseTimeout() { |
| 1680 | if (offloadingAudio()) { |
Weiyin Jiang | 35d5af1 | 2015-01-28 16:14:02 +0800 | [diff] [blame] | 1681 | mWakeLock->release(true); |
Ronghua Wu | f5b1db1 | 2014-09-09 10:11:08 -0700 | [diff] [blame] | 1682 | ++mAudioOffloadPauseTimeoutGeneration; |
| 1683 | } |
| 1684 | } |
| 1685 | |
Andy Hung | 202bce1 | 2014-12-03 11:47:36 -0800 | [diff] [blame] | 1686 | status_t NuPlayer::Renderer::onOpenAudioSink( |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 1687 | const sp<AMessage> &format, |
| 1688 | bool offloadOnly, |
| 1689 | bool hasVideo, |
| 1690 | uint32_t flags) { |
| 1691 | ALOGV("openAudioSink: offloadOnly(%d) offloadingAudio(%d)", |
| 1692 | offloadOnly, offloadingAudio()); |
| 1693 | bool audioSinkChanged = false; |
| 1694 | |
| 1695 | int32_t numChannels; |
| 1696 | CHECK(format->findInt32("channel-count", &numChannels)); |
| 1697 | |
| 1698 | int32_t channelMask; |
| 1699 | if (!format->findInt32("channel-mask", &channelMask)) { |
| 1700 | // signal to the AudioSink to derive the mask from count. |
| 1701 | channelMask = CHANNEL_MASK_USE_CHANNEL_ORDER; |
| 1702 | } |
| 1703 | |
| 1704 | int32_t sampleRate; |
| 1705 | CHECK(format->findInt32("sample-rate", &sampleRate)); |
| 1706 | |
| 1707 | if (offloadingAudio()) { |
| 1708 | audio_format_t audioFormat = AUDIO_FORMAT_PCM_16_BIT; |
| 1709 | AString mime; |
| 1710 | CHECK(format->findString("mime", &mime)); |
| 1711 | status_t err = mapMimeToAudioFormat(audioFormat, mime.c_str()); |
| 1712 | |
| 1713 | if (err != OK) { |
| 1714 | ALOGE("Couldn't map mime \"%s\" to a valid " |
| 1715 | "audio_format", mime.c_str()); |
| 1716 | onDisableOffloadAudio(); |
| 1717 | } else { |
| 1718 | ALOGV("Mime \"%s\" mapped to audio_format 0x%x", |
| 1719 | mime.c_str(), audioFormat); |
| 1720 | |
| 1721 | int avgBitRate = -1; |
| 1722 | format->findInt32("bit-rate", &avgBitRate); |
| 1723 | |
| 1724 | int32_t aacProfile = -1; |
| 1725 | if (audioFormat == AUDIO_FORMAT_AAC |
| 1726 | && format->findInt32("aac-profile", &aacProfile)) { |
| 1727 | // Redefine AAC format as per aac profile |
| 1728 | mapAACProfileToAudioFormat( |
| 1729 | audioFormat, |
| 1730 | aacProfile); |
| 1731 | } |
| 1732 | |
| 1733 | audio_offload_info_t offloadInfo = AUDIO_INFO_INITIALIZER; |
| 1734 | offloadInfo.duration_us = -1; |
| 1735 | format->findInt64( |
| 1736 | "durationUs", &offloadInfo.duration_us); |
| 1737 | offloadInfo.sample_rate = sampleRate; |
| 1738 | offloadInfo.channel_mask = channelMask; |
| 1739 | offloadInfo.format = audioFormat; |
| 1740 | offloadInfo.stream_type = AUDIO_STREAM_MUSIC; |
| 1741 | offloadInfo.bit_rate = avgBitRate; |
| 1742 | offloadInfo.has_video = hasVideo; |
| 1743 | offloadInfo.is_streaming = true; |
| 1744 | |
| 1745 | if (memcmp(&mCurrentOffloadInfo, &offloadInfo, sizeof(offloadInfo)) == 0) { |
| 1746 | ALOGV("openAudioSink: no change in offload mode"); |
| 1747 | // no change from previous configuration, everything ok. |
Andy Hung | 202bce1 | 2014-12-03 11:47:36 -0800 | [diff] [blame] | 1748 | return OK; |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 1749 | } |
Andy Hung | f0e8364 | 2014-12-19 17:55:56 -0800 | [diff] [blame] | 1750 | mCurrentPcmInfo = AUDIO_PCMINFO_INITIALIZER; |
| 1751 | |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 1752 | ALOGV("openAudioSink: try to open AudioSink in offload mode"); |
Eric Laurent | d88c3ca | 2014-10-28 10:52:11 -0700 | [diff] [blame] | 1753 | uint32_t offloadFlags = flags; |
| 1754 | offloadFlags |= AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD; |
| 1755 | offloadFlags &= ~AUDIO_OUTPUT_FLAG_DEEP_BUFFER; |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 1756 | audioSinkChanged = true; |
| 1757 | mAudioSink->close(); |
Andy Hung | a0b3971 | 2015-05-31 22:40:49 -0700 | [diff] [blame] | 1758 | |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 1759 | err = mAudioSink->open( |
| 1760 | sampleRate, |
| 1761 | numChannels, |
| 1762 | (audio_channel_mask_t)channelMask, |
| 1763 | audioFormat, |
Andy Hung | 179652e | 2015-05-31 22:49:46 -0700 | [diff] [blame] | 1764 | 0 /* bufferCount - unused */, |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 1765 | &NuPlayer::Renderer::AudioSinkCallback, |
| 1766 | this, |
Eric Laurent | d88c3ca | 2014-10-28 10:52:11 -0700 | [diff] [blame] | 1767 | (audio_output_flags_t)offloadFlags, |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 1768 | &offloadInfo); |
| 1769 | |
| 1770 | if (err == OK) { |
Lajos Molnar | 3a474aa | 2015-04-24 17:10:07 -0700 | [diff] [blame] | 1771 | err = mAudioSink->setPlaybackRate(mPlaybackSettings); |
| 1772 | } |
| 1773 | |
| 1774 | if (err == OK) { |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 1775 | // If the playback is offloaded to h/w, we pass |
| 1776 | // the HAL some metadata information. |
| 1777 | // We don't want to do this for PCM because it |
| 1778 | // will be going through the AudioFlinger mixer |
| 1779 | // before reaching the hardware. |
| 1780 | // TODO |
| 1781 | mCurrentOffloadInfo = offloadInfo; |
Andy Hung | 85e4814 | 2015-05-31 23:04:15 -0700 | [diff] [blame] | 1782 | if (!mPaused) { // for preview mode, don't start if paused |
| 1783 | err = mAudioSink->start(); |
| 1784 | } |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 1785 | ALOGV_IF(err == OK, "openAudioSink: offload succeeded"); |
| 1786 | } |
| 1787 | if (err != OK) { |
| 1788 | // Clean up, fall back to non offload mode. |
| 1789 | mAudioSink->close(); |
| 1790 | onDisableOffloadAudio(); |
| 1791 | mCurrentOffloadInfo = AUDIO_INFO_INITIALIZER; |
| 1792 | ALOGV("openAudioSink: offload failed"); |
Wei Jia | 3ab2545 | 2015-06-10 09:37:47 -0700 | [diff] [blame] | 1793 | } else { |
| 1794 | mUseAudioCallback = true; // offload mode transfers data through callback |
| 1795 | ++mAudioDrainGeneration; // discard pending kWhatDrainAudioQueue message. |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 1796 | } |
| 1797 | } |
| 1798 | } |
| 1799 | if (!offloadOnly && !offloadingAudio()) { |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 1800 | ALOGV("openAudioSink: open AudioSink in NON-offload mode"); |
Eric Laurent | d88c3ca | 2014-10-28 10:52:11 -0700 | [diff] [blame] | 1801 | uint32_t pcmFlags = flags; |
| 1802 | pcmFlags &= ~AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD; |
Andy Hung | f0e8364 | 2014-12-19 17:55:56 -0800 | [diff] [blame] | 1803 | |
| 1804 | const PcmInfo info = { |
| 1805 | (audio_channel_mask_t)channelMask, |
| 1806 | (audio_output_flags_t)pcmFlags, |
| 1807 | AUDIO_FORMAT_PCM_16_BIT, // TODO: change to audioFormat |
| 1808 | numChannels, |
| 1809 | sampleRate |
| 1810 | }; |
| 1811 | if (memcmp(&mCurrentPcmInfo, &info, sizeof(info)) == 0) { |
| 1812 | ALOGV("openAudioSink: no change in pcm mode"); |
| 1813 | // no change from previous configuration, everything ok. |
| 1814 | return OK; |
| 1815 | } |
| 1816 | |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 1817 | audioSinkChanged = true; |
| 1818 | mAudioSink->close(); |
| 1819 | mCurrentOffloadInfo = AUDIO_INFO_INITIALIZER; |
Andy Hung | a0b3971 | 2015-05-31 22:40:49 -0700 | [diff] [blame] | 1820 | // Note: It is possible to set up the callback, but not use it to send audio data. |
| 1821 | // This requires a fix in AudioSink to explicitly specify the transfer mode. |
| 1822 | mUseAudioCallback = getUseAudioCallbackSetting(); |
Wei Jia | 3ab2545 | 2015-06-10 09:37:47 -0700 | [diff] [blame] | 1823 | if (mUseAudioCallback) { |
| 1824 | ++mAudioDrainGeneration; // discard pending kWhatDrainAudioQueue message. |
| 1825 | } |
Andy Hung | 179652e | 2015-05-31 22:49:46 -0700 | [diff] [blame] | 1826 | |
| 1827 | // Compute the desired buffer size. |
| 1828 | // For callback mode, the amount of time before wakeup is about half the buffer size. |
| 1829 | const uint32_t frameCount = |
| 1830 | (unsigned long long)sampleRate * getAudioSinkPcmMsSetting() / 1000; |
| 1831 | |
Ronghua Wu | 7665f58 | 2015-09-02 10:15:30 -0700 | [diff] [blame] | 1832 | // The doNotReconnect means AudioSink will signal back and let NuPlayer to re-construct |
| 1833 | // AudioSink. We don't want this when there's video because it will cause a video seek to |
| 1834 | // the previous I frame. But we do want this when there's only audio because it will give |
| 1835 | // NuPlayer a chance to switch from non-offload mode to offload mode. |
| 1836 | // So we only set doNotReconnect when there's no video. |
| 1837 | const bool doNotReconnect = !hasVideo; |
Andy Hung | 202bce1 | 2014-12-03 11:47:36 -0800 | [diff] [blame] | 1838 | status_t err = mAudioSink->open( |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 1839 | sampleRate, |
| 1840 | numChannels, |
| 1841 | (audio_channel_mask_t)channelMask, |
| 1842 | AUDIO_FORMAT_PCM_16_BIT, |
Andy Hung | 179652e | 2015-05-31 22:49:46 -0700 | [diff] [blame] | 1843 | 0 /* bufferCount - unused */, |
Andy Hung | a0b3971 | 2015-05-31 22:40:49 -0700 | [diff] [blame] | 1844 | mUseAudioCallback ? &NuPlayer::Renderer::AudioSinkCallback : NULL, |
| 1845 | mUseAudioCallback ? this : NULL, |
Ronghua Wu | faeb0f2 | 2015-05-21 12:20:21 -0700 | [diff] [blame] | 1846 | (audio_output_flags_t)pcmFlags, |
| 1847 | NULL, |
Ronghua Wu | 7665f58 | 2015-09-02 10:15:30 -0700 | [diff] [blame] | 1848 | doNotReconnect, |
Andy Hung | 179652e | 2015-05-31 22:49:46 -0700 | [diff] [blame] | 1849 | frameCount); |
Lajos Molnar | 3a474aa | 2015-04-24 17:10:07 -0700 | [diff] [blame] | 1850 | if (err == OK) { |
| 1851 | err = mAudioSink->setPlaybackRate(mPlaybackSettings); |
| 1852 | } |
Andy Hung | 202bce1 | 2014-12-03 11:47:36 -0800 | [diff] [blame] | 1853 | if (err != OK) { |
| 1854 | ALOGW("openAudioSink: non offloaded open failed status: %d", err); |
Wei Jia | 4d7ac85 | 2015-08-31 18:33:14 -0700 | [diff] [blame] | 1855 | mAudioSink->close(); |
Andy Hung | f0e8364 | 2014-12-19 17:55:56 -0800 | [diff] [blame] | 1856 | mCurrentPcmInfo = AUDIO_PCMINFO_INITIALIZER; |
Andy Hung | 202bce1 | 2014-12-03 11:47:36 -0800 | [diff] [blame] | 1857 | return err; |
| 1858 | } |
Andy Hung | f0e8364 | 2014-12-19 17:55:56 -0800 | [diff] [blame] | 1859 | mCurrentPcmInfo = info; |
Andy Hung | 005e9d0 | 2015-05-31 23:16:07 -0700 | [diff] [blame] | 1860 | if (!mPaused) { // for preview mode, don't start if paused |
| 1861 | mAudioSink->start(); |
| 1862 | } |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 1863 | } |
| 1864 | if (audioSinkChanged) { |
| 1865 | onAudioSinkChanged(); |
| 1866 | } |
Ronghua Wu | faeb0f2 | 2015-05-21 12:20:21 -0700 | [diff] [blame] | 1867 | mAudioTornDown = false; |
Andy Hung | 202bce1 | 2014-12-03 11:47:36 -0800 | [diff] [blame] | 1868 | return OK; |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 1869 | } |
| 1870 | |
| 1871 | void NuPlayer::Renderer::onCloseAudioSink() { |
| 1872 | mAudioSink->close(); |
| 1873 | mCurrentOffloadInfo = AUDIO_INFO_INITIALIZER; |
Andy Hung | f0e8364 | 2014-12-19 17:55:56 -0800 | [diff] [blame] | 1874 | mCurrentPcmInfo = AUDIO_PCMINFO_INITIALIZER; |
Chong Zhang | 3b9eb1f | 2014-10-15 17:05:08 -0700 | [diff] [blame] | 1875 | } |
| 1876 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1877 | } // namespace android |
| 1878 | |