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
17//#define LOG_NDEBUG 0
18#define LOG_TAG "AudioPlayer"
19#include <utils/Log.h>
20
21#include <binder/IPCThreadState.h>
22#include <media/AudioTrack.h>
23#include <media/stagefright/foundation/ADebug.h>
24#include <media/stagefright/foundation/ALooper.h>
25#include <media/stagefright/AudioPlayer.h>
26#include <media/stagefright/MediaDefs.h>
27#include <media/stagefright/MediaErrors.h>
28#include <media/stagefright/MediaSource.h>
29#include <media/stagefright/MetaData.h>
30
31#include "include/AwesomePlayer.h"
32
33namespace android {
34
35AudioPlayer::AudioPlayer(
36        const sp<MediaPlayerBase::AudioSink> &audioSink,
37        bool allowDeepBuffering,
38        AwesomePlayer *observer)
39    : mAudioTrack(NULL),
40      mInputBuffer(NULL),
41      mSampleRate(0),
42      mLatencyUs(0),
43      mFrameSize(0),
44      mNumFramesPlayed(0),
45      mNumFramesPlayedSysTimeUs(ALooper::GetNowUs()),
46      mPositionTimeMediaUs(-1),
47      mPositionTimeRealUs(-1),
48      mSeeking(false),
49      mReachedEOS(false),
50      mFinalStatus(OK),
51      mStarted(false),
52      mIsFirstBuffer(false),
53      mFirstBufferResult(OK),
54      mFirstBuffer(NULL),
55      mAudioSink(audioSink),
56      mAllowDeepBuffering(allowDeepBuffering),
57      mObserver(observer),
58      mPinnedTimeUs(-1ll) {
59}
60
61AudioPlayer::~AudioPlayer() {
62    if (mStarted) {
63        reset();
64    }
65}
66
67void AudioPlayer::setSource(const sp<MediaSource> &source) {
68    CHECK(mSource == NULL);
69    mSource = source;
70}
71
72status_t AudioPlayer::start(bool sourceAlreadyStarted) {
73    CHECK(!mStarted);
74    CHECK(mSource != NULL);
75
76    status_t err;
77    if (!sourceAlreadyStarted) {
78        err = mSource->start();
79
80        if (err != OK) {
81            return err;
82        }
83    }
84
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
92    MediaSource::ReadOptions options;
93    if (mSeeking) {
94        options.setSeekTo(mSeekTimeUs);
95        mSeeking = false;
96    }
97
98    mFirstBufferResult = mSource->read(&mFirstBuffer, &options);
99    if (mFirstBufferResult == INFO_FORMAT_CHANGED) {
100        ALOGV("INFO_FORMAT_CHANGED!!!");
101
102        CHECK(mFirstBuffer == NULL);
103        mFirstBufferResult = OK;
104        mIsFirstBuffer = false;
105    } else {
106        mIsFirstBuffer = true;
107    }
108
109    sp<MetaData> format = mSource->getFormat();
110    const char *mime;
111    bool success = format->findCString(kKeyMIMEType, &mime);
112    CHECK(success);
113    CHECK(!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_RAW));
114
115    success = format->findInt32(kKeySampleRate, &mSampleRate);
116    CHECK(success);
117
118    int32_t numChannels, channelMask;
119    success = format->findInt32(kKeyChannelCount, &numChannels);
120    CHECK(success);
121
122    if(!format->findInt32(kKeyChannelMask, &channelMask)) {
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);
126        channelMask = CHANNEL_MASK_USE_CHANNEL_ORDER;
127    }
128
129    if (mAudioSink.get() != NULL) {
130
131        status_t err = mAudioSink->open(
132                mSampleRate, numChannels, channelMask, AUDIO_FORMAT_PCM_16_BIT,
133                DEFAULT_AUDIOSINK_BUFFERCOUNT,
134                &AudioPlayer::AudioSinkCallback,
135                this,
136                (mAllowDeepBuffering ?
137                            AUDIO_OUTPUT_FLAG_DEEP_BUFFER :
138                            AUDIO_OUTPUT_FLAG_NONE));
139        if (err != OK) {
140            if (mFirstBuffer != NULL) {
141                mFirstBuffer->release();
142                mFirstBuffer = NULL;
143            }
144
145            if (!sourceAlreadyStarted) {
146                mSource->stop();
147            }
148
149            return err;
150        }
151
152        mLatencyUs = (int64_t)mAudioSink->latency() * 1000;
153        mFrameSize = mAudioSink->frameSize();
154
155        mAudioSink->start();
156    } else {
157        // playing to an AudioTrack, set up mask if necessary
158        audio_channel_mask_t audioMask = channelMask == CHANNEL_MASK_USE_CHANNEL_ORDER ?
159                audio_channel_out_mask_from_count(numChannels) : channelMask;
160        if (0 == audioMask) {
161            return BAD_VALUE;
162        }
163
164        mAudioTrack = new AudioTrack(
165                AUDIO_STREAM_MUSIC, mSampleRate, AUDIO_FORMAT_PCM_16_BIT, audioMask,
166                0, AUDIO_OUTPUT_FLAG_NONE, &AudioCallback, this, 0);
167
168        if ((err = mAudioTrack->initCheck()) != OK) {
169            delete mAudioTrack;
170            mAudioTrack = NULL;
171
172            if (mFirstBuffer != NULL) {
173                mFirstBuffer->release();
174                mFirstBuffer = NULL;
175            }
176
177            if (!sourceAlreadyStarted) {
178                mSource->stop();
179            }
180
181            return err;
182        }
183
184        mLatencyUs = (int64_t)mAudioTrack->latency() * 1000;
185        mFrameSize = mAudioTrack->frameSize();
186
187        mAudioTrack->start();
188    }
189
190    mStarted = true;
191    mPinnedTimeUs = -1ll;
192
193    return OK;
194}
195
196void AudioPlayer::pause(bool playPendingSamples) {
197    CHECK(mStarted);
198
199    if (playPendingSamples) {
200        if (mAudioSink.get() != NULL) {
201            mAudioSink->stop();
202        } else {
203            mAudioTrack->stop();
204        }
205
206        mNumFramesPlayed = 0;
207        mNumFramesPlayedSysTimeUs = ALooper::GetNowUs();
208    } else {
209        if (mAudioSink.get() != NULL) {
210            mAudioSink->pause();
211        } else {
212            mAudioTrack->pause();
213        }
214
215        mPinnedTimeUs = ALooper::GetNowUs();
216    }
217}
218
219void AudioPlayer::resume() {
220    CHECK(mStarted);
221
222    if (mAudioSink.get() != NULL) {
223        mAudioSink->start();
224    } else {
225        mAudioTrack->start();
226    }
227}
228
229void AudioPlayer::reset() {
230    CHECK(mStarted);
231
232    if (mAudioSink.get() != NULL) {
233        mAudioSink->stop();
234        mAudioSink->close();
235    } else {
236        mAudioTrack->stop();
237
238        delete mAudioTrack;
239        mAudioTrack = NULL;
240    }
241
242    // Make sure to release any buffer we hold onto so that the
243    // source is able to stop().
244
245    if (mFirstBuffer != NULL) {
246        mFirstBuffer->release();
247        mFirstBuffer = NULL;
248    }
249
250    if (mInputBuffer != NULL) {
251        ALOGV("AudioPlayer releasing input buffer.");
252
253        mInputBuffer->release();
254        mInputBuffer = NULL;
255    }
256
257    mSource->stop();
258
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
269    mNumFramesPlayed = 0;
270    mNumFramesPlayedSysTimeUs = ALooper::GetNowUs();
271    mPositionTimeMediaUs = -1;
272    mPositionTimeRealUs = -1;
273    mSeeking = false;
274    mReachedEOS = false;
275    mFinalStatus = OK;
276    mStarted = false;
277}
278
279// static
280void AudioPlayer::AudioCallback(int event, void *user, void *info) {
281    static_cast<AudioPlayer *>(user)->AudioCallback(event, info);
282}
283
284bool AudioPlayer::isSeeking() {
285    Mutex::Autolock autoLock(mLock);
286    return mSeeking;
287}
288
289bool AudioPlayer::reachedEOS(status_t *finalStatus) {
290    *finalStatus = OK;
291
292    Mutex::Autolock autoLock(mLock);
293    *finalStatus = mFinalStatus;
294    return mReachedEOS;
295}
296
297status_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
307// static
308size_t AudioPlayer::AudioSinkCallback(
309        MediaPlayerBase::AudioSink *audioSink,
310        void *buffer, size_t size, void *cookie) {
311    AudioPlayer *me = (AudioPlayer *)cookie;
312
313    return me->fillBuffer(buffer, size);
314}
315
316void AudioPlayer::AudioCallback(int event, void *info) {
317    if (event != AudioTrack::EVENT_MORE_DATA) {
318        return;
319    }
320
321    AudioTrack::Buffer *buffer = (AudioTrack::Buffer *)info;
322    size_t numBytesWritten = fillBuffer(buffer->raw, buffer->size);
323
324    buffer->size = numBytesWritten;
325}
326
327uint32_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
347size_t AudioPlayer::fillBuffer(void *data, size_t size) {
348    if (mNumFramesPlayed == 0) {
349        ALOGV("AudioCallback");
350    }
351
352    if (mReachedEOS) {
353        return 0;
354    }
355
356    bool postSeekComplete = false;
357    bool postEOS = false;
358    int64_t postEOSDelayUs = 0;
359
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) {
369                if (mIsFirstBuffer) {
370                    if (mFirstBuffer != NULL) {
371                        mFirstBuffer->release();
372                        mFirstBuffer = NULL;
373                    }
374                    mIsFirstBuffer = false;
375                }
376
377                options.setSeekTo(mSeekTimeUs);
378
379                if (mInputBuffer != NULL) {
380                    mInputBuffer->release();
381                    mInputBuffer = NULL;
382                }
383
384                mSeeking = false;
385                if (mObserver) {
386                    postSeekComplete = true;
387                }
388            }
389        }
390
391        if (mInputBuffer == NULL) {
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            }
403
404            CHECK((err == OK && mInputBuffer != NULL)
405                   || (err != OK && mInputBuffer == NULL));
406
407            Mutex::Autolock autoLock(mLock);
408
409            if (err != OK) {
410                if (mObserver && !mReachedEOS) {
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
429                    ALOGV("total number of frames played: %lld (%lld us)",
430                            (mNumFramesPlayed + numAdditionalFrames),
431                            1000000ll * (mNumFramesPlayed + numAdditionalFrames)
432                                / mSampleRate);
433
434                    ALOGV("%d frames left to play, %lld us (%.2f secs)",
435                         numFramesPendingPlayout,
436                         timeToCompletionUs, timeToCompletionUs / 1E6);
437
438                    postEOS = true;
439                    if (mAudioSink->needsTrailingPadding()) {
440                        postEOSDelayUs = timeToCompletionUs + mLatencyUs;
441                    } else {
442                        postEOSDelayUs = 0;
443                    }
444                }
445
446                mReachedEOS = true;
447                mFinalStatus = err;
448                break;
449            }
450
451            if (mAudioSink != NULL) {
452                mLatencyUs = (int64_t)mAudioSink->latency() * 1000;
453            } else {
454                mLatencyUs = (int64_t)mAudioTrack->latency() * 1000;
455            }
456
457            CHECK(mInputBuffer->meta_data()->findInt64(
458                        kKeyTime, &mPositionTimeMediaUs));
459
460            mPositionTimeRealUs =
461                ((mNumFramesPlayed + size_done / mFrameSize) * 1000000)
462                    / mSampleRate;
463
464            ALOGV("buffer->size() = %d, "
465                 "mPositionTimeMediaUs=%.2f mPositionTimeRealUs=%.2f",
466                 mInputBuffer->range_length(),
467                 mPositionTimeMediaUs / 1E6, mPositionTimeRealUs / 1E6);
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);
488
489        size_done += copy;
490        size_remaining -= copy;
491    }
492
493    {
494        Mutex::Autolock autoLock(mLock);
495        mNumFramesPlayed += size_done / mFrameSize;
496        mNumFramesPlayedSysTimeUs = ALooper::GetNowUs();
497
498        if (mReachedEOS) {
499            mPinnedTimeUs = mNumFramesPlayedSysTimeUs;
500        } else {
501            mPinnedTimeUs = -1ll;
502        }
503    }
504
505    if (postEOS) {
506        mObserver->postAudioEOS(postEOSDelayUs);
507    }
508
509    if (postSeekComplete) {
510        mObserver->postAudioSeekComplete();
511    }
512
513    return size_done;
514}
515
516int64_t AudioPlayer::getRealTimeUs() {
517    Mutex::Autolock autoLock(mLock);
518    return getRealTimeUsLocked();
519}
520
521int64_t AudioPlayer::getRealTimeUsLocked() const {
522    CHECK(mStarted);
523    CHECK_NE(mSampleRate, 0);
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.
529    int64_t diffUs;
530    if (mPinnedTimeUs >= 0ll) {
531        diffUs = mPinnedTimeUs;
532    } else {
533        diffUs = ALooper::GetNowUs();
534    }
535
536    diffUs -= mNumFramesPlayedSysTimeUs;
537
538    return result + diffUs;
539}
540
541int64_t AudioPlayer::getMediaTimeUs() {
542    Mutex::Autolock autoLock(mLock);
543
544    if (mPositionTimeMediaUs < 0 || mPositionTimeRealUs < 0) {
545        if (mSeeking) {
546            return mSeekTimeUs;
547        }
548
549        return 0;
550    }
551
552    int64_t realTimeOffset = getRealTimeUsLocked() - mPositionTimeRealUs;
553    if (realTimeOffset < 0) {
554        realTimeOffset = 0;
555    }
556
557    return mPositionTimeMediaUs + realTimeOffset;
558}
559
560bool 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
567    return mPositionTimeRealUs != -1 && mPositionTimeMediaUs != -1;
568}
569
570status_t AudioPlayer::seekTo(int64_t time_us) {
571    Mutex::Autolock autoLock(mLock);
572
573    mSeeking = true;
574    mPositionTimeRealUs = mPositionTimeMediaUs = -1;
575    mReachedEOS = false;
576    mSeekTimeUs = time_us;
577
578    // Flush resets the number of played frames
579    mNumFramesPlayed = 0;
580    mNumFramesPlayedSysTimeUs = ALooper::GetNowUs();
581
582    if (mAudioSink != NULL) {
583        mAudioSink->flush();
584    } else {
585        mAudioTrack->flush();
586    }
587
588    return OK;
589}
590
591}
592