Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2009 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 | |
Andreas Huber | dae04ca | 2009-11-05 16:34:39 -0800 | [diff] [blame] | 17 | //#define LOG_NDEBUG 0 |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 18 | #define LOG_TAG "AudioPlayer" |
| 19 | #include <utils/Log.h> |
| 20 | |
Andreas Huber | 25155ff | 2010-03-01 14:27:00 -0800 | [diff] [blame] | 21 | #include <binder/IPCThreadState.h> |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 22 | #include <media/AudioTrack.h> |
Andreas Huber | f7eade9 | 2011-09-08 11:33:47 -0700 | [diff] [blame] | 23 | #include <media/stagefright/foundation/ADebug.h> |
Andreas Huber | e4451a9 | 2012-05-14 15:55:48 -0700 | [diff] [blame] | 24 | #include <media/stagefright/foundation/ALooper.h> |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 25 | #include <media/stagefright/AudioPlayer.h> |
Andreas Huber | 18291bc | 2009-09-10 14:13:30 -0700 | [diff] [blame] | 26 | #include <media/stagefright/MediaDefs.h> |
Andreas Huber | 3cc219d | 2010-07-20 09:44:34 -0700 | [diff] [blame] | 27 | #include <media/stagefright/MediaErrors.h> |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 28 | #include <media/stagefright/MediaSource.h> |
| 29 | #include <media/stagefright/MetaData.h> |
| 30 | |
Andreas Huber | ed54ad0 | 2010-09-28 11:56:39 -0700 | [diff] [blame] | 31 | #include "include/AwesomePlayer.h" |
| 32 | |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 33 | namespace android { |
| 34 | |
Andreas Huber | ed54ad0 | 2010-09-28 11:56:39 -0700 | [diff] [blame] | 35 | AudioPlayer::AudioPlayer( |
| 36 | const sp<MediaPlayerBase::AudioSink> &audioSink, |
Eric Laurent | 1948eb3 | 2012-04-13 16:50:19 -0700 | [diff] [blame] | 37 | bool allowDeepBuffering, |
Andreas Huber | ed54ad0 | 2010-09-28 11:56:39 -0700 | [diff] [blame] | 38 | AwesomePlayer *observer) |
Andreas Huber | 693d271 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 39 | : mAudioTrack(NULL), |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 40 | mInputBuffer(NULL), |
| 41 | mSampleRate(0), |
| 42 | mLatencyUs(0), |
| 43 | mFrameSize(0), |
| 44 | mNumFramesPlayed(0), |
Andreas Huber | e4451a9 | 2012-05-14 15:55:48 -0700 | [diff] [blame] | 45 | mNumFramesPlayedSysTimeUs(ALooper::GetNowUs()), |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 46 | mPositionTimeMediaUs(-1), |
| 47 | mPositionTimeRealUs(-1), |
| 48 | mSeeking(false), |
Andreas Huber | 1862a33 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 49 | mReachedEOS(false), |
Andreas Huber | 5295c0c | 2010-02-23 13:45:33 -0800 | [diff] [blame] | 50 | mFinalStatus(OK), |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 51 | mStarted(false), |
Andreas Huber | 3cc219d | 2010-07-20 09:44:34 -0700 | [diff] [blame] | 52 | mIsFirstBuffer(false), |
| 53 | mFirstBufferResult(OK), |
| 54 | mFirstBuffer(NULL), |
Andreas Huber | ed54ad0 | 2010-09-28 11:56:39 -0700 | [diff] [blame] | 55 | mAudioSink(audioSink), |
Eric Laurent | 1948eb3 | 2012-04-13 16:50:19 -0700 | [diff] [blame] | 56 | mAllowDeepBuffering(allowDeepBuffering), |
Andreas Huber | a99a5bc | 2012-05-15 15:57:59 -0700 | [diff] [blame] | 57 | mObserver(observer), |
| 58 | mPinnedTimeUs(-1ll) { |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 59 | } |
| 60 | |
| 61 | AudioPlayer::~AudioPlayer() { |
| 62 | if (mStarted) { |
Andreas Huber | b2e3954 | 2010-10-05 10:25:34 -0700 | [diff] [blame] | 63 | reset(); |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 64 | } |
| 65 | } |
| 66 | |
Andreas Huber | 693d271 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 67 | void AudioPlayer::setSource(const sp<MediaSource> &source) { |
Andreas Huber | f7eade9 | 2011-09-08 11:33:47 -0700 | [diff] [blame] | 68 | CHECK(mSource == NULL); |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 69 | mSource = source; |
| 70 | } |
| 71 | |
Andreas Huber | e7e3b78 | 2010-03-08 15:46:13 -0800 | [diff] [blame] | 72 | status_t AudioPlayer::start(bool sourceAlreadyStarted) { |
Andreas Huber | 0c89199 | 2009-08-26 14:48:20 -0700 | [diff] [blame] | 73 | CHECK(!mStarted); |
| 74 | CHECK(mSource != NULL); |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 75 | |
Andreas Huber | e7e3b78 | 2010-03-08 15:46:13 -0800 | [diff] [blame] | 76 | status_t err; |
| 77 | if (!sourceAlreadyStarted) { |
| 78 | err = mSource->start(); |
Andreas Huber | 88c030e | 2010-01-29 13:24:58 -0800 | [diff] [blame] | 79 | |
Andreas Huber | e7e3b78 | 2010-03-08 15:46:13 -0800 | [diff] [blame] | 80 | if (err != OK) { |
| 81 | return err; |
| 82 | } |
Andreas Huber | 88c030e | 2010-01-29 13:24:58 -0800 | [diff] [blame] | 83 | } |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 84 | |
Andreas Huber | 3cc219d | 2010-07-20 09:44:34 -0700 | [diff] [blame] | 85 | // We allow an optional INFO_FORMAT_CHANGED at the very beginning |
| 86 | // of playback, if there is one, getFormat below will retrieve the |
| 87 | // updated format, if there isn't, we'll stash away the valid buffer |
| 88 | // of data to be used on the first audio callback. |
| 89 | |
| 90 | CHECK(mFirstBuffer == NULL); |
| 91 | |
Andreas Huber | c0dfc5b | 2011-05-10 13:56:39 -0700 | [diff] [blame] | 92 | MediaSource::ReadOptions options; |
| 93 | if (mSeeking) { |
| 94 | options.setSeekTo(mSeekTimeUs); |
| 95 | mSeeking = false; |
| 96 | } |
| 97 | |
| 98 | mFirstBufferResult = mSource->read(&mFirstBuffer, &options); |
Andreas Huber | 3cc219d | 2010-07-20 09:44:34 -0700 | [diff] [blame] | 99 | if (mFirstBufferResult == INFO_FORMAT_CHANGED) { |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 100 | ALOGV("INFO_FORMAT_CHANGED!!!"); |
Andreas Huber | 3cc219d | 2010-07-20 09:44:34 -0700 | [diff] [blame] | 101 | |
| 102 | CHECK(mFirstBuffer == NULL); |
| 103 | mFirstBufferResult = OK; |
| 104 | mIsFirstBuffer = false; |
| 105 | } else { |
| 106 | mIsFirstBuffer = true; |
| 107 | } |
| 108 | |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 109 | sp<MetaData> format = mSource->getFormat(); |
| 110 | const char *mime; |
| 111 | bool success = format->findCString(kKeyMIMEType, &mime); |
Andreas Huber | 0c89199 | 2009-08-26 14:48:20 -0700 | [diff] [blame] | 112 | CHECK(success); |
Andreas Huber | 18291bc | 2009-09-10 14:13:30 -0700 | [diff] [blame] | 113 | CHECK(!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_RAW)); |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 114 | |
| 115 | success = format->findInt32(kKeySampleRate, &mSampleRate); |
Andreas Huber | 0c89199 | 2009-08-26 14:48:20 -0700 | [diff] [blame] | 116 | CHECK(success); |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 117 | |
Jean-Michel Trivi | 786618f | 2012-03-02 14:54:07 -0800 | [diff] [blame] | 118 | int32_t numChannels, channelMask; |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 119 | success = format->findInt32(kKeyChannelCount, &numChannels); |
Andreas Huber | 0c89199 | 2009-08-26 14:48:20 -0700 | [diff] [blame] | 120 | CHECK(success); |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 121 | |
Jean-Michel Trivi | 786618f | 2012-03-02 14:54:07 -0800 | [diff] [blame] | 122 | if(!format->findInt32(kKeyChannelMask, &channelMask)) { |
Jean-Michel Trivi | 2c3297a | 2012-05-01 14:30:58 -0700 | [diff] [blame] | 123 | // log only when there's a risk of ambiguity of channel mask selection |
| 124 | ALOGI_IF(numChannels > 2, |
| 125 | "source format didn't specify channel mask, using (%d) channel order", numChannels); |
Jean-Michel Trivi | 786618f | 2012-03-02 14:54:07 -0800 | [diff] [blame] | 126 | channelMask = CHANNEL_MASK_USE_CHANNEL_ORDER; |
| 127 | } |
| 128 | |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 129 | if (mAudioSink.get() != NULL) { |
Eric Laurent | 1948eb3 | 2012-04-13 16:50:19 -0700 | [diff] [blame] | 130 | |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 131 | status_t err = mAudioSink->open( |
Jean-Michel Trivi | 786618f | 2012-03-02 14:54:07 -0800 | [diff] [blame] | 132 | mSampleRate, numChannels, channelMask, AUDIO_FORMAT_PCM_16_BIT, |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 133 | DEFAULT_AUDIOSINK_BUFFERCOUNT, |
Eric Laurent | 1948eb3 | 2012-04-13 16:50:19 -0700 | [diff] [blame] | 134 | &AudioPlayer::AudioSinkCallback, |
| 135 | this, |
| 136 | (mAllowDeepBuffering ? |
| 137 | AUDIO_OUTPUT_FLAG_DEEP_BUFFER : |
| 138 | AUDIO_OUTPUT_FLAG_NONE)); |
Andreas Huber | 88c030e | 2010-01-29 13:24:58 -0800 | [diff] [blame] | 139 | if (err != OK) { |
Andreas Huber | 3cc219d | 2010-07-20 09:44:34 -0700 | [diff] [blame] | 140 | if (mFirstBuffer != NULL) { |
| 141 | mFirstBuffer->release(); |
| 142 | mFirstBuffer = NULL; |
| 143 | } |
| 144 | |
Andreas Huber | 4575beb | 2012-05-22 10:03:57 -0700 | [diff] [blame] | 145 | if (!sourceAlreadyStarted) { |
| 146 | mSource->stop(); |
| 147 | } |
Andreas Huber | 88c030e | 2010-01-29 13:24:58 -0800 | [diff] [blame] | 148 | |
| 149 | return err; |
| 150 | } |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 151 | |
| 152 | mLatencyUs = (int64_t)mAudioSink->latency() * 1000; |
| 153 | mFrameSize = mAudioSink->frameSize(); |
| 154 | |
| 155 | mAudioSink->start(); |
| 156 | } else { |
Jean-Michel Trivi | 786618f | 2012-03-02 14:54:07 -0800 | [diff] [blame] | 157 | // playing to an AudioTrack, set up mask if necessary |
| 158 | audio_channel_mask_t audioMask = channelMask == CHANNEL_MASK_USE_CHANNEL_ORDER ? |
Glenn Kasten | ab334fd | 2012-03-14 12:56:06 -0700 | [diff] [blame] | 159 | audio_channel_out_mask_from_count(numChannels) : channelMask; |
Jean-Michel Trivi | 786618f | 2012-03-02 14:54:07 -0800 | [diff] [blame] | 160 | if (0 == audioMask) { |
| 161 | return BAD_VALUE; |
| 162 | } |
| 163 | |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 164 | mAudioTrack = new AudioTrack( |
Jean-Michel Trivi | 786618f | 2012-03-02 14:54:07 -0800 | [diff] [blame] | 165 | AUDIO_STREAM_MUSIC, mSampleRate, AUDIO_FORMAT_PCM_16_BIT, audioMask, |
Eric Laurent | 0ca3cf9 | 2012-04-18 09:24:29 -0700 | [diff] [blame] | 166 | 0, AUDIO_OUTPUT_FLAG_NONE, &AudioCallback, this, 0); |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 167 | |
Kenny Root | 32dcebf | 2010-02-18 09:03:06 -0800 | [diff] [blame] | 168 | if ((err = mAudioTrack->initCheck()) != OK) { |
Andreas Huber | 88c030e | 2010-01-29 13:24:58 -0800 | [diff] [blame] | 169 | delete mAudioTrack; |
| 170 | mAudioTrack = NULL; |
| 171 | |
Andreas Huber | 3cc219d | 2010-07-20 09:44:34 -0700 | [diff] [blame] | 172 | if (mFirstBuffer != NULL) { |
| 173 | mFirstBuffer->release(); |
| 174 | mFirstBuffer = NULL; |
| 175 | } |
| 176 | |
Andreas Huber | 4575beb | 2012-05-22 10:03:57 -0700 | [diff] [blame] | 177 | if (!sourceAlreadyStarted) { |
| 178 | mSource->stop(); |
| 179 | } |
Andreas Huber | 88c030e | 2010-01-29 13:24:58 -0800 | [diff] [blame] | 180 | |
Kenny Root | 32dcebf | 2010-02-18 09:03:06 -0800 | [diff] [blame] | 181 | return err; |
Andreas Huber | 88c030e | 2010-01-29 13:24:58 -0800 | [diff] [blame] | 182 | } |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 183 | |
| 184 | mLatencyUs = (int64_t)mAudioTrack->latency() * 1000; |
| 185 | mFrameSize = mAudioTrack->frameSize(); |
| 186 | |
| 187 | mAudioTrack->start(); |
| 188 | } |
| 189 | |
| 190 | mStarted = true; |
Andreas Huber | a99a5bc | 2012-05-15 15:57:59 -0700 | [diff] [blame] | 191 | mPinnedTimeUs = -1ll; |
Andreas Huber | 88c030e | 2010-01-29 13:24:58 -0800 | [diff] [blame] | 192 | |
| 193 | return OK; |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 194 | } |
| 195 | |
Andreas Huber | b2e3954 | 2010-10-05 10:25:34 -0700 | [diff] [blame] | 196 | void AudioPlayer::pause(bool playPendingSamples) { |
Andreas Huber | 0c89199 | 2009-08-26 14:48:20 -0700 | [diff] [blame] | 197 | CHECK(mStarted); |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 198 | |
Andreas Huber | b2e3954 | 2010-10-05 10:25:34 -0700 | [diff] [blame] | 199 | if (playPendingSamples) { |
| 200 | if (mAudioSink.get() != NULL) { |
| 201 | mAudioSink->stop(); |
| 202 | } else { |
| 203 | mAudioTrack->stop(); |
| 204 | } |
Andreas Huber | 0b293e7 | 2011-08-26 11:26:25 -0700 | [diff] [blame] | 205 | |
| 206 | mNumFramesPlayed = 0; |
Andreas Huber | e4451a9 | 2012-05-14 15:55:48 -0700 | [diff] [blame] | 207 | mNumFramesPlayedSysTimeUs = ALooper::GetNowUs(); |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 208 | } else { |
Andreas Huber | b2e3954 | 2010-10-05 10:25:34 -0700 | [diff] [blame] | 209 | if (mAudioSink.get() != NULL) { |
| 210 | mAudioSink->pause(); |
| 211 | } else { |
| 212 | mAudioTrack->pause(); |
| 213 | } |
Andreas Huber | a99a5bc | 2012-05-15 15:57:59 -0700 | [diff] [blame] | 214 | |
| 215 | mPinnedTimeUs = ALooper::GetNowUs(); |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 216 | } |
| 217 | } |
| 218 | |
| 219 | void AudioPlayer::resume() { |
Andreas Huber | 0c89199 | 2009-08-26 14:48:20 -0700 | [diff] [blame] | 220 | CHECK(mStarted); |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 221 | |
| 222 | if (mAudioSink.get() != NULL) { |
| 223 | mAudioSink->start(); |
| 224 | } else { |
| 225 | mAudioTrack->start(); |
| 226 | } |
| 227 | } |
| 228 | |
Andreas Huber | b2e3954 | 2010-10-05 10:25:34 -0700 | [diff] [blame] | 229 | void AudioPlayer::reset() { |
Andreas Huber | 0c89199 | 2009-08-26 14:48:20 -0700 | [diff] [blame] | 230 | CHECK(mStarted); |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 231 | |
| 232 | if (mAudioSink.get() != NULL) { |
| 233 | mAudioSink->stop(); |
Andreas Huber | fc9ba09 | 2010-01-11 15:35:19 -0800 | [diff] [blame] | 234 | mAudioSink->close(); |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 235 | } else { |
| 236 | mAudioTrack->stop(); |
| 237 | |
| 238 | delete mAudioTrack; |
| 239 | mAudioTrack = NULL; |
| 240 | } |
Andreas Huber | fc9ba09 | 2010-01-11 15:35:19 -0800 | [diff] [blame] | 241 | |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 242 | // Make sure to release any buffer we hold onto so that the |
| 243 | // source is able to stop(). |
Andreas Huber | 3cc219d | 2010-07-20 09:44:34 -0700 | [diff] [blame] | 244 | |
| 245 | if (mFirstBuffer != NULL) { |
| 246 | mFirstBuffer->release(); |
| 247 | mFirstBuffer = NULL; |
| 248 | } |
| 249 | |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 250 | if (mInputBuffer != NULL) { |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 251 | ALOGV("AudioPlayer releasing input buffer."); |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 252 | |
| 253 | mInputBuffer->release(); |
| 254 | mInputBuffer = NULL; |
| 255 | } |
| 256 | |
| 257 | mSource->stop(); |
Andreas Huber | fc9ba09 | 2010-01-11 15:35:19 -0800 | [diff] [blame] | 258 | |
Andreas Huber | 25155ff | 2010-03-01 14:27:00 -0800 | [diff] [blame] | 259 | // The following hack is necessary to ensure that the OMX |
| 260 | // component is completely released by the time we may try |
| 261 | // to instantiate it again. |
| 262 | wp<MediaSource> tmp = mSource; |
| 263 | mSource.clear(); |
| 264 | while (tmp.promote() != NULL) { |
| 265 | usleep(1000); |
| 266 | } |
| 267 | IPCThreadState::self()->flushCommands(); |
| 268 | |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 269 | mNumFramesPlayed = 0; |
Andreas Huber | e4451a9 | 2012-05-14 15:55:48 -0700 | [diff] [blame] | 270 | mNumFramesPlayedSysTimeUs = ALooper::GetNowUs(); |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 271 | mPositionTimeMediaUs = -1; |
| 272 | mPositionTimeRealUs = -1; |
| 273 | mSeeking = false; |
Andreas Huber | 1862a33 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 274 | mReachedEOS = false; |
Andreas Huber | 5295c0c | 2010-02-23 13:45:33 -0800 | [diff] [blame] | 275 | mFinalStatus = OK; |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 276 | mStarted = false; |
| 277 | } |
| 278 | |
| 279 | // static |
Glenn Kasten | d217a8c | 2011-06-01 15:20:35 -0700 | [diff] [blame] | 280 | void AudioPlayer::AudioCallback(int event, void *user, void *info) { |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 281 | static_cast<AudioPlayer *>(user)->AudioCallback(event, info); |
| 282 | } |
| 283 | |
Andreas Huber | 1862a33 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 284 | bool AudioPlayer::isSeeking() { |
| 285 | Mutex::Autolock autoLock(mLock); |
| 286 | return mSeeking; |
| 287 | } |
| 288 | |
Andreas Huber | 5295c0c | 2010-02-23 13:45:33 -0800 | [diff] [blame] | 289 | bool AudioPlayer::reachedEOS(status_t *finalStatus) { |
| 290 | *finalStatus = OK; |
| 291 | |
Andreas Huber | 1862a33 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 292 | Mutex::Autolock autoLock(mLock); |
Andreas Huber | 5295c0c | 2010-02-23 13:45:33 -0800 | [diff] [blame] | 293 | *finalStatus = mFinalStatus; |
Andreas Huber | 1862a33 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 294 | return mReachedEOS; |
| 295 | } |
| 296 | |
Jean-Michel Trivi | 7a8b0ed | 2012-02-02 09:06:31 -0800 | [diff] [blame] | 297 | status_t AudioPlayer::setPlaybackRatePermille(int32_t ratePermille) { |
| 298 | if (mAudioSink.get() != NULL) { |
| 299 | return mAudioSink->setPlaybackRatePermille(ratePermille); |
| 300 | } else if (mAudioTrack != NULL){ |
| 301 | return mAudioTrack->setSampleRate(ratePermille * mSampleRate / 1000); |
| 302 | } else { |
| 303 | return NO_INIT; |
| 304 | } |
| 305 | } |
| 306 | |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 307 | // static |
Andreas Huber | 7d5b8a7 | 2010-02-09 16:59:18 -0800 | [diff] [blame] | 308 | size_t AudioPlayer::AudioSinkCallback( |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 309 | MediaPlayerBase::AudioSink *audioSink, |
| 310 | void *buffer, size_t size, void *cookie) { |
| 311 | AudioPlayer *me = (AudioPlayer *)cookie; |
| 312 | |
Andreas Huber | 7d5b8a7 | 2010-02-09 16:59:18 -0800 | [diff] [blame] | 313 | return me->fillBuffer(buffer, size); |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 314 | } |
| 315 | |
Glenn Kasten | d217a8c | 2011-06-01 15:20:35 -0700 | [diff] [blame] | 316 | void AudioPlayer::AudioCallback(int event, void *info) { |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 317 | if (event != AudioTrack::EVENT_MORE_DATA) { |
| 318 | return; |
| 319 | } |
| 320 | |
| 321 | AudioTrack::Buffer *buffer = (AudioTrack::Buffer *)info; |
Andreas Huber | 7d5b8a7 | 2010-02-09 16:59:18 -0800 | [diff] [blame] | 322 | size_t numBytesWritten = fillBuffer(buffer->raw, buffer->size); |
| 323 | |
| 324 | buffer->size = numBytesWritten; |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 325 | } |
| 326 | |
Andreas Huber | 84b343f | 2011-03-22 10:31:21 -0700 | [diff] [blame] | 327 | uint32_t AudioPlayer::getNumFramesPendingPlayout() const { |
| 328 | uint32_t numFramesPlayedOut; |
| 329 | status_t err; |
| 330 | |
| 331 | if (mAudioSink != NULL) { |
| 332 | err = mAudioSink->getPosition(&numFramesPlayedOut); |
| 333 | } else { |
| 334 | err = mAudioTrack->getPosition(&numFramesPlayedOut); |
| 335 | } |
| 336 | |
| 337 | if (err != OK || mNumFramesPlayed < numFramesPlayedOut) { |
| 338 | return 0; |
| 339 | } |
| 340 | |
| 341 | // mNumFramesPlayed is the number of frames submitted |
| 342 | // to the audio sink for playback, but not all of them |
| 343 | // may have played out by now. |
| 344 | return mNumFramesPlayed - numFramesPlayedOut; |
| 345 | } |
| 346 | |
Andreas Huber | 7d5b8a7 | 2010-02-09 16:59:18 -0800 | [diff] [blame] | 347 | size_t AudioPlayer::fillBuffer(void *data, size_t size) { |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 348 | if (mNumFramesPlayed == 0) { |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 349 | ALOGV("AudioCallback"); |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 350 | } |
| 351 | |
Andreas Huber | 1862a33 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 352 | if (mReachedEOS) { |
Andreas Huber | 51c1e0e | 2011-04-04 11:43:40 -0700 | [diff] [blame] | 353 | return 0; |
Andreas Huber | 1862a33 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 354 | } |
| 355 | |
Andreas Huber | bd7b717 | 2011-04-04 09:12:56 -0700 | [diff] [blame] | 356 | bool postSeekComplete = false; |
| 357 | bool postEOS = false; |
| 358 | int64_t postEOSDelayUs = 0; |
| 359 | |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 360 | size_t size_done = 0; |
| 361 | size_t size_remaining = size; |
| 362 | while (size_remaining > 0) { |
| 363 | MediaSource::ReadOptions options; |
| 364 | |
| 365 | { |
| 366 | Mutex::Autolock autoLock(mLock); |
| 367 | |
| 368 | if (mSeeking) { |
Andreas Huber | 3cc219d | 2010-07-20 09:44:34 -0700 | [diff] [blame] | 369 | if (mIsFirstBuffer) { |
| 370 | if (mFirstBuffer != NULL) { |
| 371 | mFirstBuffer->release(); |
| 372 | mFirstBuffer = NULL; |
| 373 | } |
| 374 | mIsFirstBuffer = false; |
| 375 | } |
| 376 | |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 377 | options.setSeekTo(mSeekTimeUs); |
| 378 | |
| 379 | if (mInputBuffer != NULL) { |
| 380 | mInputBuffer->release(); |
| 381 | mInputBuffer = NULL; |
| 382 | } |
Gloria Wang | cb9859b | 2010-02-04 17:43:09 -0800 | [diff] [blame] | 383 | |
| 384 | mSeeking = false; |
Andreas Huber | ed54ad0 | 2010-09-28 11:56:39 -0700 | [diff] [blame] | 385 | if (mObserver) { |
Andreas Huber | bd7b717 | 2011-04-04 09:12:56 -0700 | [diff] [blame] | 386 | postSeekComplete = true; |
Andreas Huber | ed54ad0 | 2010-09-28 11:56:39 -0700 | [diff] [blame] | 387 | } |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 388 | } |
| 389 | } |
| 390 | |
| 391 | if (mInputBuffer == NULL) { |
Andreas Huber | 3cc219d | 2010-07-20 09:44:34 -0700 | [diff] [blame] | 392 | status_t err; |
| 393 | |
| 394 | if (mIsFirstBuffer) { |
| 395 | mInputBuffer = mFirstBuffer; |
| 396 | mFirstBuffer = NULL; |
| 397 | err = mFirstBufferResult; |
| 398 | |
| 399 | mIsFirstBuffer = false; |
| 400 | } else { |
| 401 | err = mSource->read(&mInputBuffer, &options); |
| 402 | } |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 403 | |
Andreas Huber | 0c89199 | 2009-08-26 14:48:20 -0700 | [diff] [blame] | 404 | CHECK((err == OK && mInputBuffer != NULL) |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 405 | || (err != OK && mInputBuffer == NULL)); |
| 406 | |
Andreas Huber | 1862a33 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 407 | Mutex::Autolock autoLock(mLock); |
Andreas Huber | bfa6b2d | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 408 | |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 409 | if (err != OK) { |
Andreas Huber | ed54ad0 | 2010-09-28 11:56:39 -0700 | [diff] [blame] | 410 | if (mObserver && !mReachedEOS) { |
Andreas Huber | 84b343f | 2011-03-22 10:31:21 -0700 | [diff] [blame] | 411 | // We don't want to post EOS right away but only |
| 412 | // after all frames have actually been played out. |
| 413 | |
| 414 | // These are the number of frames submitted to the |
| 415 | // AudioTrack that you haven't heard yet. |
| 416 | uint32_t numFramesPendingPlayout = |
| 417 | getNumFramesPendingPlayout(); |
| 418 | |
| 419 | // These are the number of frames we're going to |
| 420 | // submit to the AudioTrack by returning from this |
| 421 | // callback. |
| 422 | uint32_t numAdditionalFrames = size_done / mFrameSize; |
| 423 | |
| 424 | numFramesPendingPlayout += numAdditionalFrames; |
| 425 | |
| 426 | int64_t timeToCompletionUs = |
| 427 | (1000000ll * numFramesPendingPlayout) / mSampleRate; |
| 428 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 429 | ALOGV("total number of frames played: %lld (%lld us)", |
Andreas Huber | 84b343f | 2011-03-22 10:31:21 -0700 | [diff] [blame] | 430 | (mNumFramesPlayed + numAdditionalFrames), |
| 431 | 1000000ll * (mNumFramesPlayed + numAdditionalFrames) |
| 432 | / mSampleRate); |
| 433 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 434 | ALOGV("%d frames left to play, %lld us (%.2f secs)", |
Andreas Huber | 84b343f | 2011-03-22 10:31:21 -0700 | [diff] [blame] | 435 | numFramesPendingPlayout, |
| 436 | timeToCompletionUs, timeToCompletionUs / 1E6); |
| 437 | |
Andreas Huber | bd7b717 | 2011-04-04 09:12:56 -0700 | [diff] [blame] | 438 | postEOS = true; |
Marco Nelissen | 6b74d67 | 2012-02-28 16:07:44 -0800 | [diff] [blame] | 439 | if (mAudioSink->needsTrailingPadding()) { |
| 440 | postEOSDelayUs = timeToCompletionUs + mLatencyUs; |
| 441 | } else { |
| 442 | postEOSDelayUs = 0; |
| 443 | } |
Andreas Huber | ed54ad0 | 2010-09-28 11:56:39 -0700 | [diff] [blame] | 444 | } |
| 445 | |
Andreas Huber | 1862a33 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 446 | mReachedEOS = true; |
Andreas Huber | 5295c0c | 2010-02-23 13:45:33 -0800 | [diff] [blame] | 447 | mFinalStatus = err; |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 448 | break; |
| 449 | } |
| 450 | |
Eric Laurent | db354e5 | 2012-03-05 17:27:11 -0800 | [diff] [blame] | 451 | if (mAudioSink != NULL) { |
| 452 | mLatencyUs = (int64_t)mAudioSink->latency() * 1000; |
| 453 | } else { |
| 454 | mLatencyUs = (int64_t)mAudioTrack->latency() * 1000; |
| 455 | } |
| 456 | |
Andreas Huber | 48c948b | 2009-10-08 10:07:49 -0700 | [diff] [blame] | 457 | CHECK(mInputBuffer->meta_data()->findInt64( |
| 458 | kKeyTime, &mPositionTimeMediaUs)); |
Andreas Huber | 0024245 | 2009-07-28 10:03:13 -0700 | [diff] [blame] | 459 | |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 460 | mPositionTimeRealUs = |
Eric Laurent | b48aea1 | 2012-05-04 12:55:27 -0700 | [diff] [blame] | 461 | ((mNumFramesPlayed + size_done / mFrameSize) * 1000000) |
Andreas Huber | 0024245 | 2009-07-28 10:03:13 -0700 | [diff] [blame] | 462 | / mSampleRate; |
Andreas Huber | dae04ca | 2009-11-05 16:34:39 -0800 | [diff] [blame] | 463 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 464 | ALOGV("buffer->size() = %d, " |
Andreas Huber | dae04ca | 2009-11-05 16:34:39 -0800 | [diff] [blame] | 465 | "mPositionTimeMediaUs=%.2f mPositionTimeRealUs=%.2f", |
| 466 | mInputBuffer->range_length(), |
| 467 | mPositionTimeMediaUs / 1E6, mPositionTimeRealUs / 1E6); |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 468 | } |
| 469 | |
| 470 | if (mInputBuffer->range_length() == 0) { |
| 471 | mInputBuffer->release(); |
| 472 | mInputBuffer = NULL; |
| 473 | |
| 474 | continue; |
| 475 | } |
| 476 | |
| 477 | size_t copy = size_remaining; |
| 478 | if (copy > mInputBuffer->range_length()) { |
| 479 | copy = mInputBuffer->range_length(); |
| 480 | } |
| 481 | |
| 482 | memcpy((char *)data + size_done, |
| 483 | (const char *)mInputBuffer->data() + mInputBuffer->range_offset(), |
| 484 | copy); |
| 485 | |
| 486 | mInputBuffer->set_range(mInputBuffer->range_offset() + copy, |
| 487 | mInputBuffer->range_length() - copy); |
Andreas Huber | fc9ba09 | 2010-01-11 15:35:19 -0800 | [diff] [blame] | 488 | |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 489 | size_done += copy; |
| 490 | size_remaining -= copy; |
| 491 | } |
| 492 | |
Andreas Huber | bd7b717 | 2011-04-04 09:12:56 -0700 | [diff] [blame] | 493 | { |
| 494 | Mutex::Autolock autoLock(mLock); |
| 495 | mNumFramesPlayed += size_done / mFrameSize; |
Andreas Huber | e4451a9 | 2012-05-14 15:55:48 -0700 | [diff] [blame] | 496 | mNumFramesPlayedSysTimeUs = ALooper::GetNowUs(); |
Andreas Huber | a99a5bc | 2012-05-15 15:57:59 -0700 | [diff] [blame] | 497 | |
| 498 | if (mReachedEOS) { |
| 499 | mPinnedTimeUs = mNumFramesPlayedSysTimeUs; |
| 500 | } else { |
| 501 | mPinnedTimeUs = -1ll; |
| 502 | } |
Andreas Huber | bd7b717 | 2011-04-04 09:12:56 -0700 | [diff] [blame] | 503 | } |
| 504 | |
| 505 | if (postEOS) { |
| 506 | mObserver->postAudioEOS(postEOSDelayUs); |
| 507 | } |
| 508 | |
| 509 | if (postSeekComplete) { |
| 510 | mObserver->postAudioSeekComplete(); |
| 511 | } |
Andreas Huber | 7d5b8a7 | 2010-02-09 16:59:18 -0800 | [diff] [blame] | 512 | |
| 513 | return size_done; |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 514 | } |
| 515 | |
| 516 | int64_t AudioPlayer::getRealTimeUs() { |
| 517 | Mutex::Autolock autoLock(mLock); |
| 518 | return getRealTimeUsLocked(); |
| 519 | } |
| 520 | |
| 521 | int64_t AudioPlayer::getRealTimeUsLocked() const { |
Andreas Huber | f7eade9 | 2011-09-08 11:33:47 -0700 | [diff] [blame] | 522 | CHECK(mStarted); |
| 523 | CHECK_NE(mSampleRate, 0); |
Andreas Huber | e4451a9 | 2012-05-14 15:55:48 -0700 | [diff] [blame] | 524 | int64_t result = -mLatencyUs + (mNumFramesPlayed * 1000000) / mSampleRate; |
| 525 | |
| 526 | // Compensate for large audio buffers, updates of mNumFramesPlayed |
| 527 | // are less frequent, therefore to get a "smoother" notion of time we |
| 528 | // compensate using system time. |
Andreas Huber | a99a5bc | 2012-05-15 15:57:59 -0700 | [diff] [blame] | 529 | int64_t diffUs; |
| 530 | if (mPinnedTimeUs >= 0ll) { |
| 531 | diffUs = mPinnedTimeUs; |
| 532 | } else { |
| 533 | diffUs = ALooper::GetNowUs(); |
| 534 | } |
| 535 | |
| 536 | diffUs -= mNumFramesPlayedSysTimeUs; |
Andreas Huber | e4451a9 | 2012-05-14 15:55:48 -0700 | [diff] [blame] | 537 | |
| 538 | return result + diffUs; |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 539 | } |
| 540 | |
| 541 | int64_t AudioPlayer::getMediaTimeUs() { |
| 542 | Mutex::Autolock autoLock(mLock); |
| 543 | |
Andreas Huber | ad6516d | 2010-02-03 10:23:26 -0800 | [diff] [blame] | 544 | if (mPositionTimeMediaUs < 0 || mPositionTimeRealUs < 0) { |
Andreas Huber | fe9b719 | 2011-03-25 16:36:13 -0700 | [diff] [blame] | 545 | if (mSeeking) { |
| 546 | return mSeekTimeUs; |
| 547 | } |
| 548 | |
Andreas Huber | ad6516d | 2010-02-03 10:23:26 -0800 | [diff] [blame] | 549 | return 0; |
| 550 | } |
| 551 | |
Andreas Huber | 80a68de | 2010-02-03 15:35:59 -0800 | [diff] [blame] | 552 | int64_t realTimeOffset = getRealTimeUsLocked() - mPositionTimeRealUs; |
| 553 | if (realTimeOffset < 0) { |
| 554 | realTimeOffset = 0; |
| 555 | } |
| 556 | |
| 557 | return mPositionTimeMediaUs + realTimeOffset; |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 558 | } |
| 559 | |
| 560 | bool AudioPlayer::getMediaTimeMapping( |
| 561 | int64_t *realtime_us, int64_t *mediatime_us) { |
| 562 | Mutex::Autolock autoLock(mLock); |
| 563 | |
| 564 | *realtime_us = mPositionTimeRealUs; |
| 565 | *mediatime_us = mPositionTimeMediaUs; |
| 566 | |
Andreas Huber | ad6516d | 2010-02-03 10:23:26 -0800 | [diff] [blame] | 567 | return mPositionTimeRealUs != -1 && mPositionTimeMediaUs != -1; |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 568 | } |
| 569 | |
| 570 | status_t AudioPlayer::seekTo(int64_t time_us) { |
| 571 | Mutex::Autolock autoLock(mLock); |
| 572 | |
| 573 | mSeeking = true; |
Andreas Huber | fe9b719 | 2011-03-25 16:36:13 -0700 | [diff] [blame] | 574 | mPositionTimeRealUs = mPositionTimeMediaUs = -1; |
Andreas Huber | 1862a33 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 575 | mReachedEOS = false; |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 576 | mSeekTimeUs = time_us; |
| 577 | |
James Dong | 6c37549 | 2011-09-27 22:47:25 -0700 | [diff] [blame] | 578 | // Flush resets the number of played frames |
| 579 | mNumFramesPlayed = 0; |
Andreas Huber | e4451a9 | 2012-05-14 15:55:48 -0700 | [diff] [blame] | 580 | mNumFramesPlayedSysTimeUs = ALooper::GetNowUs(); |
James Dong | 6c37549 | 2011-09-27 22:47:25 -0700 | [diff] [blame] | 581 | |
Andreas Huber | c7d368d | 2010-09-28 13:13:38 -0700 | [diff] [blame] | 582 | if (mAudioSink != NULL) { |
| 583 | mAudioSink->flush(); |
| 584 | } else { |
| 585 | mAudioTrack->flush(); |
| 586 | } |
| 587 | |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 588 | return OK; |
| 589 | } |
| 590 | |
| 591 | } |