Andreas Huber | e46b7be | 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 | c997aca | 2009-11-05 16:34:39 -0800 | [diff] [blame] | 17 | //#define LOG_NDEBUG 0 |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 18 | #define LOG_TAG "AudioPlayer" |
| 19 | #include <utils/Log.h> |
| 20 | |
Andreas Huber | 5f0d5ce | 2010-03-01 14:27:00 -0800 | [diff] [blame] | 21 | #include <binder/IPCThreadState.h> |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 22 | #include <media/AudioTrack.h> |
| 23 | #include <media/stagefright/AudioPlayer.h> |
Andreas Huber | b5ceb9e | 2009-08-26 14:48:20 -0700 | [diff] [blame] | 24 | #include <media/stagefright/MediaDebug.h> |
Andreas Huber | e6c4096 | 2009-09-10 14:13:30 -0700 | [diff] [blame] | 25 | #include <media/stagefright/MediaDefs.h> |
Andreas Huber | 16263d9 | 2010-07-20 09:44:34 -0700 | [diff] [blame] | 26 | #include <media/stagefright/MediaErrors.h> |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 27 | #include <media/stagefright/MediaSource.h> |
| 28 | #include <media/stagefright/MetaData.h> |
| 29 | |
Andreas Huber | 2b359ed | 2010-09-28 11:56:39 -0700 | [diff] [blame] | 30 | #include "include/AwesomePlayer.h" |
| 31 | |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 32 | namespace android { |
| 33 | |
Andreas Huber | 2b359ed | 2010-09-28 11:56:39 -0700 | [diff] [blame] | 34 | AudioPlayer::AudioPlayer( |
| 35 | const sp<MediaPlayerBase::AudioSink> &audioSink, |
| 36 | AwesomePlayer *observer) |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 37 | : mAudioTrack(NULL), |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 38 | mInputBuffer(NULL), |
| 39 | mSampleRate(0), |
| 40 | mLatencyUs(0), |
| 41 | mFrameSize(0), |
| 42 | mNumFramesPlayed(0), |
| 43 | mPositionTimeMediaUs(-1), |
| 44 | mPositionTimeRealUs(-1), |
| 45 | mSeeking(false), |
Andreas Huber | 70d10c0 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 46 | mReachedEOS(false), |
Andreas Huber | d7d22eb | 2010-02-23 13:45:33 -0800 | [diff] [blame] | 47 | mFinalStatus(OK), |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 48 | mStarted(false), |
Andreas Huber | 16263d9 | 2010-07-20 09:44:34 -0700 | [diff] [blame] | 49 | mIsFirstBuffer(false), |
| 50 | mFirstBufferResult(OK), |
| 51 | mFirstBuffer(NULL), |
Andreas Huber | 2b359ed | 2010-09-28 11:56:39 -0700 | [diff] [blame] | 52 | mAudioSink(audioSink), |
| 53 | mObserver(observer) { |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 54 | } |
| 55 | |
| 56 | AudioPlayer::~AudioPlayer() { |
| 57 | if (mStarted) { |
Andreas Huber | c743f45 | 2010-10-05 10:25:34 -0700 | [diff] [blame] | 58 | reset(); |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 59 | } |
| 60 | } |
| 61 | |
Andreas Huber | be06d26 | 2009-08-14 14:37:10 -0700 | [diff] [blame] | 62 | void AudioPlayer::setSource(const sp<MediaSource> &source) { |
Andreas Huber | b5ceb9e | 2009-08-26 14:48:20 -0700 | [diff] [blame] | 63 | CHECK_EQ(mSource, NULL); |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 64 | mSource = source; |
| 65 | } |
| 66 | |
Andreas Huber | dc9927d | 2010-03-08 15:46:13 -0800 | [diff] [blame] | 67 | status_t AudioPlayer::start(bool sourceAlreadyStarted) { |
Andreas Huber | b5ceb9e | 2009-08-26 14:48:20 -0700 | [diff] [blame] | 68 | CHECK(!mStarted); |
| 69 | CHECK(mSource != NULL); |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 70 | |
Andreas Huber | dc9927d | 2010-03-08 15:46:13 -0800 | [diff] [blame] | 71 | status_t err; |
| 72 | if (!sourceAlreadyStarted) { |
| 73 | err = mSource->start(); |
Andreas Huber | 62eac00 | 2010-01-29 13:24:58 -0800 | [diff] [blame] | 74 | |
Andreas Huber | dc9927d | 2010-03-08 15:46:13 -0800 | [diff] [blame] | 75 | if (err != OK) { |
| 76 | return err; |
| 77 | } |
Andreas Huber | 62eac00 | 2010-01-29 13:24:58 -0800 | [diff] [blame] | 78 | } |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 79 | |
Andreas Huber | 16263d9 | 2010-07-20 09:44:34 -0700 | [diff] [blame] | 80 | // We allow an optional INFO_FORMAT_CHANGED at the very beginning |
| 81 | // of playback, if there is one, getFormat below will retrieve the |
| 82 | // updated format, if there isn't, we'll stash away the valid buffer |
| 83 | // of data to be used on the first audio callback. |
| 84 | |
| 85 | CHECK(mFirstBuffer == NULL); |
| 86 | |
| 87 | mFirstBufferResult = mSource->read(&mFirstBuffer); |
| 88 | if (mFirstBufferResult == INFO_FORMAT_CHANGED) { |
| 89 | LOGV("INFO_FORMAT_CHANGED!!!"); |
| 90 | |
| 91 | CHECK(mFirstBuffer == NULL); |
| 92 | mFirstBufferResult = OK; |
| 93 | mIsFirstBuffer = false; |
| 94 | } else { |
| 95 | mIsFirstBuffer = true; |
| 96 | } |
| 97 | |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 98 | sp<MetaData> format = mSource->getFormat(); |
| 99 | const char *mime; |
| 100 | bool success = format->findCString(kKeyMIMEType, &mime); |
Andreas Huber | b5ceb9e | 2009-08-26 14:48:20 -0700 | [diff] [blame] | 101 | CHECK(success); |
Andreas Huber | e6c4096 | 2009-09-10 14:13:30 -0700 | [diff] [blame] | 102 | CHECK(!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_RAW)); |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 103 | |
| 104 | success = format->findInt32(kKeySampleRate, &mSampleRate); |
Andreas Huber | b5ceb9e | 2009-08-26 14:48:20 -0700 | [diff] [blame] | 105 | CHECK(success); |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 106 | |
| 107 | int32_t numChannels; |
| 108 | success = format->findInt32(kKeyChannelCount, &numChannels); |
Andreas Huber | b5ceb9e | 2009-08-26 14:48:20 -0700 | [diff] [blame] | 109 | CHECK(success); |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 110 | |
| 111 | if (mAudioSink.get() != NULL) { |
| 112 | status_t err = mAudioSink->open( |
| 113 | mSampleRate, numChannels, AudioSystem::PCM_16_BIT, |
| 114 | DEFAULT_AUDIOSINK_BUFFERCOUNT, |
| 115 | &AudioPlayer::AudioSinkCallback, this); |
Andreas Huber | 62eac00 | 2010-01-29 13:24:58 -0800 | [diff] [blame] | 116 | if (err != OK) { |
Andreas Huber | 16263d9 | 2010-07-20 09:44:34 -0700 | [diff] [blame] | 117 | if (mFirstBuffer != NULL) { |
| 118 | mFirstBuffer->release(); |
| 119 | mFirstBuffer = NULL; |
| 120 | } |
| 121 | |
| 122 | if (!sourceAlreadyStarted) { |
| 123 | mSource->stop(); |
| 124 | } |
Andreas Huber | 62eac00 | 2010-01-29 13:24:58 -0800 | [diff] [blame] | 125 | |
| 126 | return err; |
| 127 | } |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 128 | |
| 129 | mLatencyUs = (int64_t)mAudioSink->latency() * 1000; |
| 130 | mFrameSize = mAudioSink->frameSize(); |
| 131 | |
| 132 | mAudioSink->start(); |
| 133 | } else { |
| 134 | mAudioTrack = new AudioTrack( |
| 135 | AudioSystem::MUSIC, mSampleRate, AudioSystem::PCM_16_BIT, |
Andreas Huber | 8a43277 | 2009-07-28 10:03:13 -0700 | [diff] [blame] | 136 | (numChannels == 2) |
| 137 | ? AudioSystem::CHANNEL_OUT_STEREO |
| 138 | : AudioSystem::CHANNEL_OUT_MONO, |
Andreas Huber | 662292a | 2010-04-13 09:58:39 -0700 | [diff] [blame] | 139 | 0, 0, &AudioCallback, this, 0); |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 140 | |
Kenny Root | 3cbd62c | 2010-02-18 09:03:06 -0800 | [diff] [blame] | 141 | if ((err = mAudioTrack->initCheck()) != OK) { |
Andreas Huber | 62eac00 | 2010-01-29 13:24:58 -0800 | [diff] [blame] | 142 | delete mAudioTrack; |
| 143 | mAudioTrack = NULL; |
| 144 | |
Andreas Huber | 16263d9 | 2010-07-20 09:44:34 -0700 | [diff] [blame] | 145 | if (mFirstBuffer != NULL) { |
| 146 | mFirstBuffer->release(); |
| 147 | mFirstBuffer = NULL; |
| 148 | } |
| 149 | |
| 150 | if (!sourceAlreadyStarted) { |
| 151 | mSource->stop(); |
| 152 | } |
Andreas Huber | 62eac00 | 2010-01-29 13:24:58 -0800 | [diff] [blame] | 153 | |
Kenny Root | 3cbd62c | 2010-02-18 09:03:06 -0800 | [diff] [blame] | 154 | return err; |
Andreas Huber | 62eac00 | 2010-01-29 13:24:58 -0800 | [diff] [blame] | 155 | } |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 156 | |
| 157 | mLatencyUs = (int64_t)mAudioTrack->latency() * 1000; |
| 158 | mFrameSize = mAudioTrack->frameSize(); |
| 159 | |
| 160 | mAudioTrack->start(); |
| 161 | } |
| 162 | |
| 163 | mStarted = true; |
Andreas Huber | 62eac00 | 2010-01-29 13:24:58 -0800 | [diff] [blame] | 164 | |
| 165 | return OK; |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 166 | } |
| 167 | |
Andreas Huber | c743f45 | 2010-10-05 10:25:34 -0700 | [diff] [blame] | 168 | void AudioPlayer::pause(bool playPendingSamples) { |
Andreas Huber | b5ceb9e | 2009-08-26 14:48:20 -0700 | [diff] [blame] | 169 | CHECK(mStarted); |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 170 | |
Andreas Huber | c743f45 | 2010-10-05 10:25:34 -0700 | [diff] [blame] | 171 | if (playPendingSamples) { |
| 172 | if (mAudioSink.get() != NULL) { |
| 173 | mAudioSink->stop(); |
| 174 | } else { |
| 175 | mAudioTrack->stop(); |
| 176 | } |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 177 | } else { |
Andreas Huber | c743f45 | 2010-10-05 10:25:34 -0700 | [diff] [blame] | 178 | if (mAudioSink.get() != NULL) { |
| 179 | mAudioSink->pause(); |
| 180 | } else { |
| 181 | mAudioTrack->pause(); |
| 182 | } |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 183 | } |
| 184 | } |
| 185 | |
| 186 | void AudioPlayer::resume() { |
Andreas Huber | b5ceb9e | 2009-08-26 14:48:20 -0700 | [diff] [blame] | 187 | CHECK(mStarted); |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 188 | |
| 189 | if (mAudioSink.get() != NULL) { |
| 190 | mAudioSink->start(); |
| 191 | } else { |
| 192 | mAudioTrack->start(); |
| 193 | } |
| 194 | } |
| 195 | |
Andreas Huber | c743f45 | 2010-10-05 10:25:34 -0700 | [diff] [blame] | 196 | void AudioPlayer::reset() { |
Andreas Huber | b5ceb9e | 2009-08-26 14:48:20 -0700 | [diff] [blame] | 197 | CHECK(mStarted); |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 198 | |
| 199 | if (mAudioSink.get() != NULL) { |
| 200 | mAudioSink->stop(); |
Andreas Huber | aee3c63 | 2010-01-11 15:35:19 -0800 | [diff] [blame] | 201 | mAudioSink->close(); |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 202 | } else { |
| 203 | mAudioTrack->stop(); |
| 204 | |
| 205 | delete mAudioTrack; |
| 206 | mAudioTrack = NULL; |
| 207 | } |
Andreas Huber | aee3c63 | 2010-01-11 15:35:19 -0800 | [diff] [blame] | 208 | |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 209 | // Make sure to release any buffer we hold onto so that the |
| 210 | // source is able to stop(). |
Andreas Huber | 16263d9 | 2010-07-20 09:44:34 -0700 | [diff] [blame] | 211 | |
| 212 | if (mFirstBuffer != NULL) { |
| 213 | mFirstBuffer->release(); |
| 214 | mFirstBuffer = NULL; |
| 215 | } |
| 216 | |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 217 | if (mInputBuffer != NULL) { |
Andreas Huber | c997aca | 2009-11-05 16:34:39 -0800 | [diff] [blame] | 218 | LOGV("AudioPlayer releasing input buffer."); |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 219 | |
| 220 | mInputBuffer->release(); |
| 221 | mInputBuffer = NULL; |
| 222 | } |
| 223 | |
| 224 | mSource->stop(); |
Andreas Huber | aee3c63 | 2010-01-11 15:35:19 -0800 | [diff] [blame] | 225 | |
Andreas Huber | 5f0d5ce | 2010-03-01 14:27:00 -0800 | [diff] [blame] | 226 | // The following hack is necessary to ensure that the OMX |
| 227 | // component is completely released by the time we may try |
| 228 | // to instantiate it again. |
| 229 | wp<MediaSource> tmp = mSource; |
| 230 | mSource.clear(); |
| 231 | while (tmp.promote() != NULL) { |
| 232 | usleep(1000); |
| 233 | } |
| 234 | IPCThreadState::self()->flushCommands(); |
| 235 | |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 236 | mNumFramesPlayed = 0; |
| 237 | mPositionTimeMediaUs = -1; |
| 238 | mPositionTimeRealUs = -1; |
| 239 | mSeeking = false; |
Andreas Huber | 70d10c0 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 240 | mReachedEOS = false; |
Andreas Huber | d7d22eb | 2010-02-23 13:45:33 -0800 | [diff] [blame] | 241 | mFinalStatus = OK; |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 242 | mStarted = false; |
| 243 | } |
| 244 | |
| 245 | // static |
| 246 | void AudioPlayer::AudioCallback(int event, void *user, void *info) { |
| 247 | static_cast<AudioPlayer *>(user)->AudioCallback(event, info); |
| 248 | } |
| 249 | |
Andreas Huber | 70d10c0 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 250 | bool AudioPlayer::isSeeking() { |
| 251 | Mutex::Autolock autoLock(mLock); |
| 252 | return mSeeking; |
| 253 | } |
| 254 | |
Andreas Huber | d7d22eb | 2010-02-23 13:45:33 -0800 | [diff] [blame] | 255 | bool AudioPlayer::reachedEOS(status_t *finalStatus) { |
| 256 | *finalStatus = OK; |
| 257 | |
Andreas Huber | 70d10c0 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 258 | Mutex::Autolock autoLock(mLock); |
Andreas Huber | d7d22eb | 2010-02-23 13:45:33 -0800 | [diff] [blame] | 259 | *finalStatus = mFinalStatus; |
Andreas Huber | 70d10c0 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 260 | return mReachedEOS; |
| 261 | } |
| 262 | |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 263 | // static |
Andreas Huber | 6ed937e | 2010-02-09 16:59:18 -0800 | [diff] [blame] | 264 | size_t AudioPlayer::AudioSinkCallback( |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 265 | MediaPlayerBase::AudioSink *audioSink, |
| 266 | void *buffer, size_t size, void *cookie) { |
| 267 | AudioPlayer *me = (AudioPlayer *)cookie; |
| 268 | |
Andreas Huber | 6ed937e | 2010-02-09 16:59:18 -0800 | [diff] [blame] | 269 | return me->fillBuffer(buffer, size); |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 270 | } |
| 271 | |
| 272 | void AudioPlayer::AudioCallback(int event, void *info) { |
| 273 | if (event != AudioTrack::EVENT_MORE_DATA) { |
| 274 | return; |
| 275 | } |
| 276 | |
| 277 | AudioTrack::Buffer *buffer = (AudioTrack::Buffer *)info; |
Andreas Huber | 6ed937e | 2010-02-09 16:59:18 -0800 | [diff] [blame] | 278 | size_t numBytesWritten = fillBuffer(buffer->raw, buffer->size); |
| 279 | |
| 280 | buffer->size = numBytesWritten; |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 281 | } |
| 282 | |
Andreas Huber | 6ed937e | 2010-02-09 16:59:18 -0800 | [diff] [blame] | 283 | size_t AudioPlayer::fillBuffer(void *data, size_t size) { |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 284 | if (mNumFramesPlayed == 0) { |
Andreas Huber | c997aca | 2009-11-05 16:34:39 -0800 | [diff] [blame] | 285 | LOGV("AudioCallback"); |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 286 | } |
| 287 | |
Andreas Huber | 70d10c0 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 288 | if (mReachedEOS) { |
Andreas Huber | 4aeec2d | 2011-01-26 10:41:38 -0800 | [diff] [blame] | 289 | memset(data, 0, size); |
| 290 | |
| 291 | return size; |
Andreas Huber | 70d10c0 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 292 | } |
| 293 | |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 294 | size_t size_done = 0; |
| 295 | size_t size_remaining = size; |
| 296 | while (size_remaining > 0) { |
| 297 | MediaSource::ReadOptions options; |
| 298 | |
| 299 | { |
| 300 | Mutex::Autolock autoLock(mLock); |
| 301 | |
| 302 | if (mSeeking) { |
Andreas Huber | 16263d9 | 2010-07-20 09:44:34 -0700 | [diff] [blame] | 303 | if (mIsFirstBuffer) { |
| 304 | if (mFirstBuffer != NULL) { |
| 305 | mFirstBuffer->release(); |
| 306 | mFirstBuffer = NULL; |
| 307 | } |
| 308 | mIsFirstBuffer = false; |
| 309 | } |
| 310 | |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 311 | options.setSeekTo(mSeekTimeUs); |
| 312 | |
| 313 | if (mInputBuffer != NULL) { |
| 314 | mInputBuffer->release(); |
| 315 | mInputBuffer = NULL; |
| 316 | } |
Gloria Wang | 2b7bb21 | 2010-02-04 17:43:09 -0800 | [diff] [blame] | 317 | |
| 318 | mSeeking = false; |
Andreas Huber | 2b359ed | 2010-09-28 11:56:39 -0700 | [diff] [blame] | 319 | if (mObserver) { |
| 320 | mObserver->postAudioSeekComplete(); |
| 321 | } |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 322 | } |
| 323 | } |
| 324 | |
| 325 | if (mInputBuffer == NULL) { |
Andreas Huber | 16263d9 | 2010-07-20 09:44:34 -0700 | [diff] [blame] | 326 | status_t err; |
| 327 | |
| 328 | if (mIsFirstBuffer) { |
| 329 | mInputBuffer = mFirstBuffer; |
| 330 | mFirstBuffer = NULL; |
| 331 | err = mFirstBufferResult; |
| 332 | |
| 333 | mIsFirstBuffer = false; |
| 334 | } else { |
| 335 | err = mSource->read(&mInputBuffer, &options); |
| 336 | } |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 337 | |
Andreas Huber | b5ceb9e | 2009-08-26 14:48:20 -0700 | [diff] [blame] | 338 | CHECK((err == OK && mInputBuffer != NULL) |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 339 | || (err != OK && mInputBuffer == NULL)); |
| 340 | |
Andreas Huber | 70d10c0 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 341 | Mutex::Autolock autoLock(mLock); |
Andreas Huber | 27366fc | 2009-11-20 09:32:46 -0800 | [diff] [blame] | 342 | |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 343 | if (err != OK) { |
Andreas Huber | 2b359ed | 2010-09-28 11:56:39 -0700 | [diff] [blame] | 344 | if (mObserver && !mReachedEOS) { |
| 345 | mObserver->postAudioEOS(); |
| 346 | } |
| 347 | |
Andreas Huber | 70d10c0 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 348 | mReachedEOS = true; |
Andreas Huber | d7d22eb | 2010-02-23 13:45:33 -0800 | [diff] [blame] | 349 | mFinalStatus = err; |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 350 | break; |
| 351 | } |
| 352 | |
Andreas Huber | fa8de75 | 2009-10-08 10:07:49 -0700 | [diff] [blame] | 353 | CHECK(mInputBuffer->meta_data()->findInt64( |
| 354 | kKeyTime, &mPositionTimeMediaUs)); |
Andreas Huber | 8a43277 | 2009-07-28 10:03:13 -0700 | [diff] [blame] | 355 | |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 356 | mPositionTimeRealUs = |
Andreas Huber | 065f69e | 2010-02-03 15:35:59 -0800 | [diff] [blame] | 357 | ((mNumFramesPlayed + size_done / mFrameSize) * 1000000) |
Andreas Huber | 8a43277 | 2009-07-28 10:03:13 -0700 | [diff] [blame] | 358 | / mSampleRate; |
Andreas Huber | c997aca | 2009-11-05 16:34:39 -0800 | [diff] [blame] | 359 | |
| 360 | LOGV("buffer->size() = %d, " |
| 361 | "mPositionTimeMediaUs=%.2f mPositionTimeRealUs=%.2f", |
| 362 | mInputBuffer->range_length(), |
| 363 | mPositionTimeMediaUs / 1E6, mPositionTimeRealUs / 1E6); |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 364 | } |
| 365 | |
| 366 | if (mInputBuffer->range_length() == 0) { |
| 367 | mInputBuffer->release(); |
| 368 | mInputBuffer = NULL; |
| 369 | |
| 370 | continue; |
| 371 | } |
| 372 | |
| 373 | size_t copy = size_remaining; |
| 374 | if (copy > mInputBuffer->range_length()) { |
| 375 | copy = mInputBuffer->range_length(); |
| 376 | } |
| 377 | |
| 378 | memcpy((char *)data + size_done, |
| 379 | (const char *)mInputBuffer->data() + mInputBuffer->range_offset(), |
| 380 | copy); |
| 381 | |
| 382 | mInputBuffer->set_range(mInputBuffer->range_offset() + copy, |
| 383 | mInputBuffer->range_length() - copy); |
Andreas Huber | aee3c63 | 2010-01-11 15:35:19 -0800 | [diff] [blame] | 384 | |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 385 | size_done += copy; |
| 386 | size_remaining -= copy; |
| 387 | } |
| 388 | |
| 389 | Mutex::Autolock autoLock(mLock); |
Andreas Huber | 6ed937e | 2010-02-09 16:59:18 -0800 | [diff] [blame] | 390 | mNumFramesPlayed += size_done / mFrameSize; |
| 391 | |
| 392 | return size_done; |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 393 | } |
| 394 | |
| 395 | int64_t AudioPlayer::getRealTimeUs() { |
| 396 | Mutex::Autolock autoLock(mLock); |
| 397 | return getRealTimeUsLocked(); |
| 398 | } |
| 399 | |
| 400 | int64_t AudioPlayer::getRealTimeUsLocked() const { |
| 401 | return -mLatencyUs + (mNumFramesPlayed * 1000000) / mSampleRate; |
| 402 | } |
| 403 | |
| 404 | int64_t AudioPlayer::getMediaTimeUs() { |
| 405 | Mutex::Autolock autoLock(mLock); |
| 406 | |
Andreas Huber | c119f7e | 2010-02-03 10:23:26 -0800 | [diff] [blame] | 407 | if (mPositionTimeMediaUs < 0 || mPositionTimeRealUs < 0) { |
Andreas Huber | 59529e1 | 2011-03-25 16:36:13 -0700 | [diff] [blame] | 408 | if (mSeeking) { |
| 409 | return mSeekTimeUs; |
| 410 | } |
| 411 | |
Andreas Huber | c119f7e | 2010-02-03 10:23:26 -0800 | [diff] [blame] | 412 | return 0; |
| 413 | } |
| 414 | |
Andreas Huber | 065f69e | 2010-02-03 15:35:59 -0800 | [diff] [blame] | 415 | int64_t realTimeOffset = getRealTimeUsLocked() - mPositionTimeRealUs; |
| 416 | if (realTimeOffset < 0) { |
| 417 | realTimeOffset = 0; |
| 418 | } |
| 419 | |
| 420 | return mPositionTimeMediaUs + realTimeOffset; |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 421 | } |
| 422 | |
| 423 | bool AudioPlayer::getMediaTimeMapping( |
| 424 | int64_t *realtime_us, int64_t *mediatime_us) { |
| 425 | Mutex::Autolock autoLock(mLock); |
| 426 | |
| 427 | *realtime_us = mPositionTimeRealUs; |
| 428 | *mediatime_us = mPositionTimeMediaUs; |
| 429 | |
Andreas Huber | c119f7e | 2010-02-03 10:23:26 -0800 | [diff] [blame] | 430 | return mPositionTimeRealUs != -1 && mPositionTimeMediaUs != -1; |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 431 | } |
| 432 | |
| 433 | status_t AudioPlayer::seekTo(int64_t time_us) { |
| 434 | Mutex::Autolock autoLock(mLock); |
| 435 | |
| 436 | mSeeking = true; |
Andreas Huber | 59529e1 | 2011-03-25 16:36:13 -0700 | [diff] [blame] | 437 | mPositionTimeRealUs = mPositionTimeMediaUs = -1; |
Andreas Huber | 70d10c0 | 2010-02-03 11:37:29 -0800 | [diff] [blame] | 438 | mReachedEOS = false; |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 439 | mSeekTimeUs = time_us; |
| 440 | |
Andreas Huber | ad3fcfe | 2010-09-28 13:13:38 -0700 | [diff] [blame] | 441 | if (mAudioSink != NULL) { |
| 442 | mAudioSink->flush(); |
| 443 | } else { |
| 444 | mAudioTrack->flush(); |
| 445 | } |
| 446 | |
Andreas Huber | e46b7be | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 447 | return OK; |
| 448 | } |
| 449 | |
| 450 | } |