NuPlayerRenderer.cpp revision 230b188b2c2ed74aa017cb93f847e9a558feba95 
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"
22
23#include <media/stagefright/foundation/ABuffer.h>
24#include <media/stagefright/foundation/ADebug.h>
25#include <media/stagefright/foundation/AMessage.h>
26#include <media/stagefright/foundation/AUtils.h>
27#include <media/stagefright/foundation/AWakeLock.h>
28#include <media/stagefright/MediaClock.h>
29#include <media/stagefright/MediaErrors.h>
30#include <media/stagefright/MetaData.h>
31#include <media/stagefright/Utils.h>
32
33#include <VideoFrameScheduler.h>
34
35#include <inttypes.h>
36
37namespace android {
38
39// Maximum time in paused state when offloading audio decompression. When elapsed, the AudioSink
40// is closed to allow the audio DSP to power down.
41static const int64_t kOffloadPauseMaxUs = 10000000ll;
42
43// static
44const NuPlayer::Renderer::PcmInfo NuPlayer::Renderer::AUDIO_PCMINFO_INITIALIZER = {
45        AUDIO_CHANNEL_NONE,
46        AUDIO_OUTPUT_FLAG_NONE,
47        AUDIO_FORMAT_INVALID,
48        0, // mNumChannels
49        0 // mSampleRate
50};
51
52// static
53const int64_t NuPlayer::Renderer::kMinPositionUpdateDelayUs = 100000ll;
54
55NuPlayer::Renderer::Renderer(
56        const sp<MediaPlayerBase::AudioSink> &sink,
57        const sp<AMessage> &notify,
58        uint32_t flags)
59    : mAudioSink(sink),
60      mNotify(notify),
61      mFlags(flags),
62      mNumFramesWritten(0),
63      mDrainAudioQueuePending(false),
64      mDrainVideoQueuePending(false),
65      mAudioQueueGeneration(0),
66      mVideoQueueGeneration(0),
67      mAudioDrainGeneration(0),
68      mVideoDrainGeneration(0),
69      mPlaybackRate(1.0),
70      mAudioFirstAnchorTimeMediaUs(-1),
71      mAnchorTimeMediaUs(-1),
72      mAnchorNumFramesWritten(-1),
73      mVideoLateByUs(0ll),
74      mHasAudio(false),
75      mHasVideo(false),
76      mNotifyCompleteAudio(false),
77      mNotifyCompleteVideo(false),
78      mSyncQueues(false),
79      mPaused(false),
80      mVideoSampleReceived(false),
81      mVideoRenderingStarted(false),
82      mVideoRenderingStartGeneration(0),
83      mAudioRenderingStartGeneration(0),
84      mAudioOffloadPauseTimeoutGeneration(0),
85      mAudioOffloadTornDown(false),
86      mCurrentOffloadInfo(AUDIO_INFO_INITIALIZER),
87      mCurrentPcmInfo(AUDIO_PCMINFO_INITIALIZER),
88      mTotalBuffersQueued(0),
89      mLastAudioBufferDrained(0),
90      mWakeLock(new AWakeLock()) {
91    mMediaClock = new MediaClock;
92}
93
94NuPlayer::Renderer::~Renderer() {
95    if (offloadingAudio()) {
96        mAudioSink->stop();
97        mAudioSink->flush();
98        mAudioSink->close();
99    }
100}
101
102void NuPlayer::Renderer::queueBuffer(
103        bool audio,
104        const sp<ABuffer> &buffer,
105        const sp<AMessage> &notifyConsumed) {
106    sp<AMessage> msg = new AMessage(kWhatQueueBuffer, this);
107    msg->setInt32("queueGeneration", getQueueGeneration(audio));
108    msg->setInt32("audio", static_cast<int32_t>(audio));
109    msg->setBuffer("buffer", buffer);
110    msg->setMessage("notifyConsumed", notifyConsumed);
111    msg->post();
112}
113
114void NuPlayer::Renderer::queueEOS(bool audio, status_t finalResult) {
115    CHECK_NE(finalResult, (status_t)OK);
116
117    sp<AMessage> msg = new AMessage(kWhatQueueEOS, this);
118    msg->setInt32("queueGeneration", getQueueGeneration(audio));
119    msg->setInt32("audio", static_cast<int32_t>(audio));
120    msg->setInt32("finalResult", finalResult);
121    msg->post();
122}
123
124void NuPlayer::Renderer::setPlaybackRate(float rate) {
125    sp<AMessage> msg = new AMessage(kWhatSetRate, this);
126    msg->setFloat("rate", rate);
127    msg->post();
128}
129
130void NuPlayer::Renderer::flush(bool audio, bool notifyComplete) {
131    {
132        Mutex::Autolock autoLock(mLock);
133        if (audio) {
134            mNotifyCompleteAudio |= notifyComplete;
135            ++mAudioQueueGeneration;
136            ++mAudioDrainGeneration;
137        } else {
138            mNotifyCompleteVideo |= notifyComplete;
139            ++mVideoQueueGeneration;
140            ++mVideoDrainGeneration;
141        }
142
143        clearAnchorTime_l();
144        clearAudioFirstAnchorTime_l();
145        mVideoLateByUs = 0;
146        mSyncQueues = false;
147    }
148
149    sp<AMessage> msg = new AMessage(kWhatFlush, this);
150    msg->setInt32("audio", static_cast<int32_t>(audio));
151    msg->post();
152}
153
154void NuPlayer::Renderer::signalTimeDiscontinuity() {
155}
156
157void NuPlayer::Renderer::signalDisableOffloadAudio() {
158    (new AMessage(kWhatDisableOffloadAudio, this))->post();
159}
160
161void NuPlayer::Renderer::signalEnableOffloadAudio() {
162    (new AMessage(kWhatEnableOffloadAudio, this))->post();
163}
164
165void NuPlayer::Renderer::pause() {
166    (new AMessage(kWhatPause, this))->post();
167}
168
169void NuPlayer::Renderer::resume() {
170    (new AMessage(kWhatResume, this))->post();
171}
172
173void NuPlayer::Renderer::setVideoFrameRate(float fps) {
174    sp<AMessage> msg = new AMessage(kWhatSetVideoFrameRate, this);
175    msg->setFloat("frame-rate", fps);
176    msg->post();
177}
178
179// Called on any threads.
180status_t NuPlayer::Renderer::getCurrentPosition(int64_t *mediaUs) {
181    return mMediaClock->getMediaTime(ALooper::GetNowUs(), mediaUs);
182}
183
184void NuPlayer::Renderer::clearAudioFirstAnchorTime_l() {
185    mAudioFirstAnchorTimeMediaUs = -1;
186    mMediaClock->setStartingTimeMedia(-1);
187}
188
189void NuPlayer::Renderer::setAudioFirstAnchorTimeIfNeeded_l(int64_t mediaUs) {
190    if (mAudioFirstAnchorTimeMediaUs == -1) {
191        mAudioFirstAnchorTimeMediaUs = mediaUs;
192        mMediaClock->setStartingTimeMedia(mediaUs);
193    }
194}
195
196void NuPlayer::Renderer::clearAnchorTime_l() {
197    mMediaClock->clearAnchor();
198    mAnchorTimeMediaUs = -1;
199    mAnchorNumFramesWritten = -1;
200}
201
202void NuPlayer::Renderer::setVideoLateByUs(int64_t lateUs) {
203    Mutex::Autolock autoLock(mLock);
204    mVideoLateByUs = lateUs;
205}
206
207int64_t NuPlayer::Renderer::getVideoLateByUs() {
208    Mutex::Autolock autoLock(mLock);
209    return mVideoLateByUs;
210}
211
212status_t NuPlayer::Renderer::openAudioSink(
213        const sp<AMessage> &format,
214        bool offloadOnly,
215        bool hasVideo,
216        uint32_t flags,
217        bool *isOffloaded) {
218    sp<AMessage> msg = new AMessage(kWhatOpenAudioSink, this);
219    msg->setMessage("format", format);
220    msg->setInt32("offload-only", offloadOnly);
221    msg->setInt32("has-video", hasVideo);
222    msg->setInt32("flags", flags);
223
224    sp<AMessage> response;
225    msg->postAndAwaitResponse(&response);
226
227    int32_t err;
228    if (!response->findInt32("err", &err)) {
229        err = INVALID_OPERATION;
230    } else if (err == OK && isOffloaded != NULL) {
231        int32_t offload;
232        CHECK(response->findInt32("offload", &offload));
233        *isOffloaded = (offload != 0);
234    }
235    return err;
236}
237
238void NuPlayer::Renderer::closeAudioSink() {
239    sp<AMessage> msg = new AMessage(kWhatCloseAudioSink, this);
240
241    sp<AMessage> response;
242    msg->postAndAwaitResponse(&response);
243}
244
245void NuPlayer::Renderer::onMessageReceived(const sp<AMessage> &msg) {
246    switch (msg->what()) {
247        case kWhatOpenAudioSink:
248        {
249            sp<AMessage> format;
250            CHECK(msg->findMessage("format", &format));
251
252            int32_t offloadOnly;
253            CHECK(msg->findInt32("offload-only", &offloadOnly));
254
255            int32_t hasVideo;
256            CHECK(msg->findInt32("has-video", &hasVideo));
257
258            uint32_t flags;
259            CHECK(msg->findInt32("flags", (int32_t *)&flags));
260
261            status_t err = onOpenAudioSink(format, offloadOnly, hasVideo, flags);
262
263            sp<AMessage> response = new AMessage;
264            response->setInt32("err", err);
265            response->setInt32("offload", offloadingAudio());
266
267            sp<AReplyToken> replyID;
268            CHECK(msg->senderAwaitsResponse(&replyID));
269            response->postReply(replyID);
270
271            break;
272        }
273
274        case kWhatCloseAudioSink:
275        {
276            sp<AReplyToken> replyID;
277            CHECK(msg->senderAwaitsResponse(&replyID));
278
279            onCloseAudioSink();
280
281            sp<AMessage> response = new AMessage;
282            response->postReply(replyID);
283            break;
284        }
285
286        case kWhatStopAudioSink:
287        {
288            mAudioSink->stop();
289            break;
290        }
291
292        case kWhatDrainAudioQueue:
293        {
294            int32_t generation;
295            CHECK(msg->findInt32("drainGeneration", &generation));
296            if (generation != getDrainGeneration(true /* audio */)) {
297                break;
298            }
299
300            mDrainAudioQueuePending = false;
301
302            if (onDrainAudioQueue()) {
303                uint32_t numFramesPlayed;
304                CHECK_EQ(mAudioSink->getPosition(&numFramesPlayed),
305                         (status_t)OK);
306
307                uint32_t numFramesPendingPlayout =
308                    mNumFramesWritten - numFramesPlayed;
309
310                // This is how long the audio sink will have data to
311                // play back.
312                int64_t delayUs =
313                    mAudioSink->msecsPerFrame()
314                        * numFramesPendingPlayout * 1000ll;
315
316                // Let's give it more data after about half that time
317                // has elapsed.
318                Mutex::Autolock autoLock(mLock);
319                postDrainAudioQueue_l(delayUs / 2);
320            }
321            break;
322        }
323
324        case kWhatDrainVideoQueue:
325        {
326            int32_t generation;
327            CHECK(msg->findInt32("drainGeneration", &generation));
328            if (generation != getDrainGeneration(false /* audio */)) {
329                break;
330            }
331
332            mDrainVideoQueuePending = false;
333
334            onDrainVideoQueue();
335
336            postDrainVideoQueue();
337            break;
338        }
339
340        case kWhatPostDrainVideoQueue:
341        {
342            int32_t generation;
343            CHECK(msg->findInt32("drainGeneration", &generation));
344            if (generation != getDrainGeneration(false /* audio */)) {
345                break;
346            }
347
348            mDrainVideoQueuePending = false;
349            postDrainVideoQueue();
350            break;
351        }
352
353        case kWhatQueueBuffer:
354        {
355            onQueueBuffer(msg);
356            break;
357        }
358
359        case kWhatQueueEOS:
360        {
361            onQueueEOS(msg);
362            break;
363        }
364
365        case kWhatSetRate:
366        {
367            CHECK(msg->findFloat("rate", &mPlaybackRate));
368            int32_t ratePermille = (int32_t)(0.5f + 1000 * mPlaybackRate);
369            mPlaybackRate = ratePermille / 1000.0f;
370            mMediaClock->setPlaybackRate(mPlaybackRate);
371            mAudioSink->setPlaybackRatePermille(ratePermille);
372            break;
373        }
374
375        case kWhatFlush:
376        {
377            onFlush(msg);
378            break;
379        }
380
381        case kWhatDisableOffloadAudio:
382        {
383            onDisableOffloadAudio();
384            break;
385        }
386
387        case kWhatEnableOffloadAudio:
388        {
389            onEnableOffloadAudio();
390            break;
391        }
392
393        case kWhatPause:
394        {
395            onPause();
396            break;
397        }
398
399        case kWhatResume:
400        {
401            onResume();
402            break;
403        }
404
405        case kWhatSetVideoFrameRate:
406        {
407            float fps;
408            CHECK(msg->findFloat("frame-rate", &fps));
409            onSetVideoFrameRate(fps);
410            break;
411        }
412
413        case kWhatAudioOffloadTearDown:
414        {
415            onAudioOffloadTearDown(kDueToError);
416            break;
417        }
418
419        case kWhatAudioOffloadPauseTimeout:
420        {
421            int32_t generation;
422            CHECK(msg->findInt32("drainGeneration", &generation));
423            if (generation != mAudioOffloadPauseTimeoutGeneration) {
424                break;
425            }
426            ALOGV("Audio Offload tear down due to pause timeout.");
427            onAudioOffloadTearDown(kDueToTimeout);
428            mWakeLock->release();
429            break;
430        }
431
432        default:
433            TRESPASS();
434            break;
435    }
436}
437
438void NuPlayer::Renderer::postDrainAudioQueue_l(int64_t delayUs) {
439    if (mDrainAudioQueuePending || mSyncQueues || mPaused
440            || offloadingAudio()) {
441        return;
442    }
443
444    if (mAudioQueue.empty()) {
445        return;
446    }
447
448    mDrainAudioQueuePending = true;
449    sp<AMessage> msg = new AMessage(kWhatDrainAudioQueue, this);
450    msg->setInt32("drainGeneration", mAudioDrainGeneration);
451    msg->post(delayUs);
452}
453
454void NuPlayer::Renderer::prepareForMediaRenderingStart_l() {
455    mAudioRenderingStartGeneration = mAudioDrainGeneration;
456    mVideoRenderingStartGeneration = mVideoDrainGeneration;
457}
458
459void NuPlayer::Renderer::notifyIfMediaRenderingStarted_l() {
460    if (mVideoRenderingStartGeneration == mVideoDrainGeneration &&
461        mAudioRenderingStartGeneration == mAudioDrainGeneration) {
462        mVideoRenderingStartGeneration = -1;
463        mAudioRenderingStartGeneration = -1;
464
465        sp<AMessage> notify = mNotify->dup();
466        notify->setInt32("what", kWhatMediaRenderingStart);
467        notify->post();
468    }
469}
470
471// static
472size_t NuPlayer::Renderer::AudioSinkCallback(
473        MediaPlayerBase::AudioSink * /* audioSink */,
474        void *buffer,
475        size_t size,
476        void *cookie,
477        MediaPlayerBase::AudioSink::cb_event_t event) {
478    NuPlayer::Renderer *me = (NuPlayer::Renderer *)cookie;
479
480    switch (event) {
481        case MediaPlayerBase::AudioSink::CB_EVENT_FILL_BUFFER:
482        {
483            return me->fillAudioBuffer(buffer, size);
484            break;
485        }
486
487        case MediaPlayerBase::AudioSink::CB_EVENT_STREAM_END:
488        {
489            me->notifyEOS(true /* audio */, ERROR_END_OF_STREAM);
490            break;
491        }
492
493        case MediaPlayerBase::AudioSink::CB_EVENT_TEAR_DOWN:
494        {
495            me->notifyAudioOffloadTearDown();
496            break;
497        }
498    }
499
500    return 0;
501}
502
503size_t NuPlayer::Renderer::fillAudioBuffer(void *buffer, size_t size) {
504    Mutex::Autolock autoLock(mLock);
505
506    if (!offloadingAudio() || mPaused) {
507        return 0;
508    }
509
510    bool hasEOS = false;
511
512    size_t sizeCopied = 0;
513    bool firstEntry = true;
514    while (sizeCopied < size && !mAudioQueue.empty()) {
515        QueueEntry *entry = &*mAudioQueue.begin();
516
517        if (entry->mBuffer == NULL) { // EOS
518            hasEOS = true;
519            mAudioQueue.erase(mAudioQueue.begin());
520            entry = NULL;
521            break;
522        }
523
524        if (firstEntry && entry->mOffset == 0) {
525            firstEntry = false;
526            int64_t mediaTimeUs;
527            CHECK(entry->mBuffer->meta()->findInt64("timeUs", &mediaTimeUs));
528            ALOGV("rendering audio at media time %.2f secs", mediaTimeUs / 1E6);
529            setAudioFirstAnchorTimeIfNeeded_l(mediaTimeUs);
530        }
531
532        size_t copy = entry->mBuffer->size() - entry->mOffset;
533        size_t sizeRemaining = size - sizeCopied;
534        if (copy > sizeRemaining) {
535            copy = sizeRemaining;
536        }
537
538        memcpy((char *)buffer + sizeCopied,
539               entry->mBuffer->data() + entry->mOffset,
540               copy);
541
542        entry->mOffset += copy;
543        if (entry->mOffset == entry->mBuffer->size()) {
544            entry->mNotifyConsumed->post();
545            mAudioQueue.erase(mAudioQueue.begin());
546            entry = NULL;
547        }
548        sizeCopied += copy;
549
550        notifyIfMediaRenderingStarted_l();
551    }
552
553    if (mAudioFirstAnchorTimeMediaUs >= 0) {
554        int64_t nowUs = ALooper::GetNowUs();
555        int64_t nowMediaUs =
556            mAudioFirstAnchorTimeMediaUs + getPlayedOutAudioDurationUs(nowUs);
557        // we don't know how much data we are queueing for offloaded tracks.
558        mMediaClock->updateAnchor(nowMediaUs, nowUs, INT64_MAX);
559    }
560
561    if (hasEOS) {
562        (new AMessage(kWhatStopAudioSink, this))->post();
563    }
564
565    return sizeCopied;
566}
567
568bool NuPlayer::Renderer::onDrainAudioQueue() {
569    // TODO: This call to getPosition checks if AudioTrack has been created
570    // in AudioSink before draining audio. If AudioTrack doesn't exist, then
571    // CHECKs on getPosition will fail.
572    // We still need to figure out why AudioTrack is not created when
573    // this function is called. One possible reason could be leftover
574    // audio. Another possible place is to check whether decoder
575    // has received INFO_FORMAT_CHANGED as the first buffer since
576    // AudioSink is opened there, and possible interactions with flush
577    // immediately after start. Investigate error message
578    // "vorbis_dsp_synthesis returned -135", along with RTSP.
579    uint32_t numFramesPlayed;
580    if (mAudioSink->getPosition(&numFramesPlayed) != OK) {
581        return false;
582    }
583
584#if 0
585    ssize_t numFramesAvailableToWrite =
586        mAudioSink->frameCount() - (mNumFramesWritten - numFramesPlayed);
587
588    if (numFramesAvailableToWrite == mAudioSink->frameCount()) {
589        ALOGI("audio sink underrun");
590    } else {
591        ALOGV("audio queue has %d frames left to play",
592             mAudioSink->frameCount() - numFramesAvailableToWrite);
593    }
594#endif
595
596    while (!mAudioQueue.empty()) {
597        QueueEntry *entry = &*mAudioQueue.begin();
598
599        mLastAudioBufferDrained = entry->mBufferOrdinal;
600
601        if (entry->mBuffer == NULL) {
602            // EOS
603            int64_t postEOSDelayUs = 0;
604            if (mAudioSink->needsTrailingPadding()) {
605                postEOSDelayUs = getPendingAudioPlayoutDurationUs(ALooper::GetNowUs());
606            }
607            notifyEOS(true /* audio */, entry->mFinalResult, postEOSDelayUs);
608
609            mAudioQueue.erase(mAudioQueue.begin());
610            entry = NULL;
611            if (mAudioSink->needsTrailingPadding()) {
612                // If we're not in gapless playback (i.e. through setNextPlayer), we
613                // need to stop the track here, because that will play out the last
614                // little bit at the end of the file. Otherwise short files won't play.
615                mAudioSink->stop();
616                mNumFramesWritten = 0;
617            }
618            return false;
619        }
620
621        if (entry->mOffset == 0) {
622            int64_t mediaTimeUs;
623            CHECK(entry->mBuffer->meta()->findInt64("timeUs", &mediaTimeUs));
624            ALOGV("rendering audio at media time %.2f secs", mediaTimeUs / 1E6);
625            onNewAudioMediaTime(mediaTimeUs);
626        }
627
628        size_t copy = entry->mBuffer->size() - entry->mOffset;
629
630        ssize_t written = mAudioSink->write(entry->mBuffer->data() + entry->mOffset,
631                                            copy, false /* blocking */);
632        if (written < 0) {
633            // An error in AudioSink write. Perhaps the AudioSink was not properly opened.
634            if (written == WOULD_BLOCK) {
635                ALOGW("AudioSink write would block when writing %zu bytes", copy);
636            } else {
637                ALOGE("AudioSink write error(%zd) when writing %zu bytes", written, copy);
638            }
639            break;
640        }
641
642        entry->mOffset += written;
643        if (entry->mOffset == entry->mBuffer->size()) {
644            entry->mNotifyConsumed->post();
645            mAudioQueue.erase(mAudioQueue.begin());
646
647            entry = NULL;
648        }
649
650        size_t copiedFrames = written / mAudioSink->frameSize();
651        mNumFramesWritten += copiedFrames;
652
653        {
654            Mutex::Autolock autoLock(mLock);
655            notifyIfMediaRenderingStarted_l();
656        }
657
658        if (written != (ssize_t)copy) {
659            // A short count was received from AudioSink::write()
660            //
661            // AudioSink write is called in non-blocking mode.
662            // It may return with a short count when:
663            //
664            // 1) Size to be copied is not a multiple of the frame size. We consider this fatal.
665            // 2) The data to be copied exceeds the available buffer in AudioSink.
666            // 3) An error occurs and data has been partially copied to the buffer in AudioSink.
667            // 4) AudioSink is an AudioCache for data retrieval, and the AudioCache is exceeded.
668
669            // (Case 1)
670            // Must be a multiple of the frame size.  If it is not a multiple of a frame size, it
671            // needs to fail, as we should not carry over fractional frames between calls.
672            CHECK_EQ(copy % mAudioSink->frameSize(), 0);
673
674            // (Case 2, 3, 4)
675            // Return early to the caller.
676            // Beware of calling immediately again as this may busy-loop if you are not careful.
677            ALOGV("AudioSink write short frame count %zd < %zu", written, copy);
678            break;
679        }
680    }
681    int64_t maxTimeMedia;
682    {
683        Mutex::Autolock autoLock(mLock);
684        maxTimeMedia =
685            mAnchorTimeMediaUs +
686                    (int64_t)(max((long long)mNumFramesWritten - mAnchorNumFramesWritten, 0LL)
687                            * 1000LL * mAudioSink->msecsPerFrame());
688    }
689    mMediaClock->updateMaxTimeMedia(maxTimeMedia);
690
691    return !mAudioQueue.empty();
692}
693
694int64_t NuPlayer::Renderer::getDurationUsIfPlayedAtSampleRate(uint32_t numFrames) {
695    int32_t sampleRate = offloadingAudio() ?
696            mCurrentOffloadInfo.sample_rate : mCurrentPcmInfo.mSampleRate;
697    // TODO: remove the (int32_t) casting below as it may overflow at 12.4 hours.
698    return (int64_t)((int32_t)numFrames * 1000000LL / sampleRate);
699}
700
701// Calculate duration of pending samples if played at normal rate (i.e., 1.0).
702int64_t NuPlayer::Renderer::getPendingAudioPlayoutDurationUs(int64_t nowUs) {
703    int64_t writtenAudioDurationUs = getDurationUsIfPlayedAtSampleRate(mNumFramesWritten);
704    return writtenAudioDurationUs - getPlayedOutAudioDurationUs(nowUs);
705}
706
707int64_t NuPlayer::Renderer::getRealTimeUs(int64_t mediaTimeUs, int64_t nowUs) {
708    int64_t realUs;
709    if (mMediaClock->getRealTimeFor(mediaTimeUs, &realUs) != OK) {
710        // If failed to get current position, e.g. due to audio clock is
711        // not ready, then just play out video immediately without delay.
712        return nowUs;
713    }
714    return realUs;
715}
716
717void NuPlayer::Renderer::onNewAudioMediaTime(int64_t mediaTimeUs) {
718    Mutex::Autolock autoLock(mLock);
719    // TRICKY: vorbis decoder generates multiple frames with the same
720    // timestamp, so only update on the first frame with a given timestamp
721    if (mediaTimeUs == mAnchorTimeMediaUs) {
722        return;
723    }
724    setAudioFirstAnchorTimeIfNeeded_l(mediaTimeUs);
725    int64_t nowUs = ALooper::GetNowUs();
726    int64_t nowMediaUs = mediaTimeUs - getPendingAudioPlayoutDurationUs(nowUs);
727    mMediaClock->updateAnchor(nowMediaUs, nowUs, mediaTimeUs);
728    mAnchorNumFramesWritten = mNumFramesWritten;
729    mAnchorTimeMediaUs = mediaTimeUs;
730}
731
732// Called without mLock acquired.
733void NuPlayer::Renderer::postDrainVideoQueue() {
734    if (mDrainVideoQueuePending
735            || getSyncQueues()
736            || (mPaused && mVideoSampleReceived)) {
737        return;
738    }
739
740    if (mVideoQueue.empty()) {
741        return;
742    }
743
744    QueueEntry &entry = *mVideoQueue.begin();
745
746    sp<AMessage> msg = new AMessage(kWhatDrainVideoQueue, this);
747    msg->setInt32("drainGeneration", getDrainGeneration(false /* audio */));
748
749    if (entry.mBuffer == NULL) {
750        // EOS doesn't carry a timestamp.
751        msg->post();
752        mDrainVideoQueuePending = true;
753        return;
754    }
755
756    int64_t delayUs;
757    int64_t nowUs = ALooper::GetNowUs();
758    int64_t realTimeUs;
759    if (mFlags & FLAG_REAL_TIME) {
760        int64_t mediaTimeUs;
761        CHECK(entry.mBuffer->meta()->findInt64("timeUs", &mediaTimeUs));
762        realTimeUs = mediaTimeUs;
763    } else {
764        int64_t mediaTimeUs;
765        CHECK(entry.mBuffer->meta()->findInt64("timeUs", &mediaTimeUs));
766
767        {
768            Mutex::Autolock autoLock(mLock);
769            if (mAnchorTimeMediaUs < 0) {
770                mMediaClock->updateAnchor(mediaTimeUs, nowUs, mediaTimeUs);
771                mAnchorTimeMediaUs = mediaTimeUs;
772                realTimeUs = nowUs;
773            } else {
774                realTimeUs = getRealTimeUs(mediaTimeUs, nowUs);
775            }
776        }
777        if (!mHasAudio) {
778            // smooth out videos >= 10fps
779            mMediaClock->updateMaxTimeMedia(mediaTimeUs + 100000);
780        }
781
782        // Heuristics to handle situation when media time changed without a
783        // discontinuity. If we have not drained an audio buffer that was
784        // received after this buffer, repost in 10 msec. Otherwise repost
785        // in 500 msec.
786        delayUs = realTimeUs - nowUs;
787        if (delayUs > 500000) {
788            int64_t postDelayUs = 500000;
789            if (mHasAudio && (mLastAudioBufferDrained - entry.mBufferOrdinal) <= 0) {
790                postDelayUs = 10000;
791            }
792            msg->setWhat(kWhatPostDrainVideoQueue);
793            msg->post(postDelayUs);
794            mVideoScheduler->restart();
795            ALOGI("possible video time jump of %dms, retrying in %dms",
796                    (int)(delayUs / 1000), (int)(postDelayUs / 1000));
797            mDrainVideoQueuePending = true;
798            return;
799        }
800    }
801
802    realTimeUs = mVideoScheduler->schedule(realTimeUs * 1000) / 1000;
803    int64_t twoVsyncsUs = 2 * (mVideoScheduler->getVsyncPeriod() / 1000);
804
805    delayUs = realTimeUs - nowUs;
806
807    ALOGW_IF(delayUs > 500000, "unusually high delayUs: %" PRId64, delayUs);
808    // post 2 display refreshes before rendering is due
809    msg->post(delayUs > twoVsyncsUs ? delayUs - twoVsyncsUs : 0);
810
811    mDrainVideoQueuePending = true;
812}
813
814void NuPlayer::Renderer::onDrainVideoQueue() {
815    if (mVideoQueue.empty()) {
816        return;
817    }
818
819    QueueEntry *entry = &*mVideoQueue.begin();
820
821    if (entry->mBuffer == NULL) {
822        // EOS
823
824        notifyEOS(false /* audio */, entry->mFinalResult);
825
826        mVideoQueue.erase(mVideoQueue.begin());
827        entry = NULL;
828
829        setVideoLateByUs(0);
830        return;
831    }
832
833    int64_t nowUs = -1;
834    int64_t realTimeUs;
835    if (mFlags & FLAG_REAL_TIME) {
836        CHECK(entry->mBuffer->meta()->findInt64("timeUs", &realTimeUs));
837    } else {
838        int64_t mediaTimeUs;
839        CHECK(entry->mBuffer->meta()->findInt64("timeUs", &mediaTimeUs));
840
841        nowUs = ALooper::GetNowUs();
842        realTimeUs = getRealTimeUs(mediaTimeUs, nowUs);
843    }
844
845    bool tooLate = false;
846
847    if (!mPaused) {
848        if (nowUs == -1) {
849            nowUs = ALooper::GetNowUs();
850        }
851        setVideoLateByUs(nowUs - realTimeUs);
852        tooLate = (mVideoLateByUs > 40000);
853
854        if (tooLate) {
855            ALOGV("video late by %lld us (%.2f secs)",
856                 mVideoLateByUs, mVideoLateByUs / 1E6);
857        } else {
858            int64_t mediaUs = 0;
859            mMediaClock->getMediaTime(realTimeUs, &mediaUs);
860            ALOGV("rendering video at media time %.2f secs",
861                    (mFlags & FLAG_REAL_TIME ? realTimeUs :
862                    mediaUs) / 1E6);
863        }
864    } else {
865        setVideoLateByUs(0);
866        if (!mVideoSampleReceived && !mHasAudio) {
867            // This will ensure that the first frame after a flush won't be used as anchor
868            // when renderer is in paused state, because resume can happen any time after seek.
869            Mutex::Autolock autoLock(mLock);
870            clearAnchorTime_l();
871        }
872    }
873
874    entry->mNotifyConsumed->setInt64("timestampNs", realTimeUs * 1000ll);
875    entry->mNotifyConsumed->setInt32("render", !tooLate);
876    entry->mNotifyConsumed->post();
877    mVideoQueue.erase(mVideoQueue.begin());
878    entry = NULL;
879
880    mVideoSampleReceived = true;
881
882    if (!mPaused) {
883        if (!mVideoRenderingStarted) {
884            mVideoRenderingStarted = true;
885            notifyVideoRenderingStart();
886        }
887        Mutex::Autolock autoLock(mLock);
888        notifyIfMediaRenderingStarted_l();
889    }
890}
891
892void NuPlayer::Renderer::notifyVideoRenderingStart() {
893    sp<AMessage> notify = mNotify->dup();
894    notify->setInt32("what", kWhatVideoRenderingStart);
895    notify->post();
896}
897
898void NuPlayer::Renderer::notifyEOS(bool audio, status_t finalResult, int64_t delayUs) {
899    sp<AMessage> notify = mNotify->dup();
900    notify->setInt32("what", kWhatEOS);
901    notify->setInt32("audio", static_cast<int32_t>(audio));
902    notify->setInt32("finalResult", finalResult);
903    notify->post(delayUs);
904}
905
906void NuPlayer::Renderer::notifyAudioOffloadTearDown() {
907    (new AMessage(kWhatAudioOffloadTearDown, this))->post();
908}
909
910void NuPlayer::Renderer::onQueueBuffer(const sp<AMessage> &msg) {
911    int32_t audio;
912    CHECK(msg->findInt32("audio", &audio));
913
914    if (dropBufferIfStale(audio, msg)) {
915        return;
916    }
917
918    if (audio) {
919        mHasAudio = true;
920    } else {
921        mHasVideo = true;
922    }
923
924    if (mHasVideo) {
925        if (mVideoScheduler == NULL) {
926            mVideoScheduler = new VideoFrameScheduler();
927            mVideoScheduler->init();
928        }
929    }
930
931    sp<ABuffer> buffer;
932    CHECK(msg->findBuffer("buffer", &buffer));
933
934    sp<AMessage> notifyConsumed;
935    CHECK(msg->findMessage("notifyConsumed", &notifyConsumed));
936
937    QueueEntry entry;
938    entry.mBuffer = buffer;
939    entry.mNotifyConsumed = notifyConsumed;
940    entry.mOffset = 0;
941    entry.mFinalResult = OK;
942    entry.mBufferOrdinal = ++mTotalBuffersQueued;
943
944    if (audio) {
945        Mutex::Autolock autoLock(mLock);
946        mAudioQueue.push_back(entry);
947        postDrainAudioQueue_l();
948    } else {
949        mVideoQueue.push_back(entry);
950        postDrainVideoQueue();
951    }
952
953    Mutex::Autolock autoLock(mLock);
954    if (!mSyncQueues || mAudioQueue.empty() || mVideoQueue.empty()) {
955        return;
956    }
957
958    sp<ABuffer> firstAudioBuffer = (*mAudioQueue.begin()).mBuffer;
959    sp<ABuffer> firstVideoBuffer = (*mVideoQueue.begin()).mBuffer;
960
961    if (firstAudioBuffer == NULL || firstVideoBuffer == NULL) {
962        // EOS signalled on either queue.
963        syncQueuesDone_l();
964        return;
965    }
966
967    int64_t firstAudioTimeUs;
968    int64_t firstVideoTimeUs;
969    CHECK(firstAudioBuffer->meta()
970            ->findInt64("timeUs", &firstAudioTimeUs));
971    CHECK(firstVideoBuffer->meta()
972            ->findInt64("timeUs", &firstVideoTimeUs));
973
974    int64_t diff = firstVideoTimeUs - firstAudioTimeUs;
975
976    ALOGV("queueDiff = %.2f secs", diff / 1E6);
977
978    if (diff > 100000ll) {
979        // Audio data starts More than 0.1 secs before video.
980        // Drop some audio.
981
982        (*mAudioQueue.begin()).mNotifyConsumed->post();
983        mAudioQueue.erase(mAudioQueue.begin());
984        return;
985    }
986
987    syncQueuesDone_l();
988}
989
990void NuPlayer::Renderer::syncQueuesDone_l() {
991    if (!mSyncQueues) {
992        return;
993    }
994
995    mSyncQueues = false;
996
997    if (!mAudioQueue.empty()) {
998        postDrainAudioQueue_l();
999    }
1000
1001    if (!mVideoQueue.empty()) {
1002        mLock.unlock();
1003        postDrainVideoQueue();
1004        mLock.lock();
1005    }
1006}
1007
1008void NuPlayer::Renderer::onQueueEOS(const sp<AMessage> &msg) {
1009    int32_t audio;
1010    CHECK(msg->findInt32("audio", &audio));
1011
1012    if (dropBufferIfStale(audio, msg)) {
1013        return;
1014    }
1015
1016    int32_t finalResult;
1017    CHECK(msg->findInt32("finalResult", &finalResult));
1018
1019    QueueEntry entry;
1020    entry.mOffset = 0;
1021    entry.mFinalResult = finalResult;
1022
1023    if (audio) {
1024        Mutex::Autolock autoLock(mLock);
1025        if (mAudioQueue.empty() && mSyncQueues) {
1026            syncQueuesDone_l();
1027        }
1028        mAudioQueue.push_back(entry);
1029        postDrainAudioQueue_l();
1030    } else {
1031        if (mVideoQueue.empty() && getSyncQueues()) {
1032            Mutex::Autolock autoLock(mLock);
1033            syncQueuesDone_l();
1034        }
1035        mVideoQueue.push_back(entry);
1036        postDrainVideoQueue();
1037    }
1038}
1039
1040void NuPlayer::Renderer::onFlush(const sp<AMessage> &msg) {
1041    int32_t audio, notifyComplete;
1042    CHECK(msg->findInt32("audio", &audio));
1043
1044    {
1045        Mutex::Autolock autoLock(mLock);
1046        if (audio) {
1047            notifyComplete = mNotifyCompleteAudio;
1048            mNotifyCompleteAudio = false;
1049        } else {
1050            notifyComplete = mNotifyCompleteVideo;
1051            mNotifyCompleteVideo = false;
1052        }
1053
1054        // If we're currently syncing the queues, i.e. dropping audio while
1055        // aligning the first audio/video buffer times and only one of the
1056        // two queues has data, we may starve that queue by not requesting
1057        // more buffers from the decoder. If the other source then encounters
1058        // a discontinuity that leads to flushing, we'll never find the
1059        // corresponding discontinuity on the other queue.
1060        // Therefore we'll stop syncing the queues if at least one of them
1061        // is flushed.
1062        syncQueuesDone_l();
1063        clearAnchorTime_l();
1064    }
1065
1066    ALOGV("flushing %s", audio ? "audio" : "video");
1067    if (audio) {
1068        {
1069            Mutex::Autolock autoLock(mLock);
1070            flushQueue(&mAudioQueue);
1071
1072            ++mAudioDrainGeneration;
1073            prepareForMediaRenderingStart_l();
1074
1075            if (offloadingAudio()) {
1076                clearAudioFirstAnchorTime_l();
1077            }
1078        }
1079
1080        mDrainAudioQueuePending = false;
1081
1082        if (offloadingAudio()) {
1083            mAudioSink->pause();
1084            mAudioSink->flush();
1085            mAudioSink->start();
1086        }
1087    } else {
1088        flushQueue(&mVideoQueue);
1089
1090        mDrainVideoQueuePending = false;
1091
1092        if (mVideoScheduler != NULL) {
1093            mVideoScheduler->restart();
1094        }
1095
1096        Mutex::Autolock autoLock(mLock);
1097        ++mVideoDrainGeneration;
1098        prepareForMediaRenderingStart_l();
1099    }
1100
1101    mVideoSampleReceived = false;
1102
1103    if (notifyComplete) {
1104        notifyFlushComplete(audio);
1105    }
1106}
1107
1108void NuPlayer::Renderer::flushQueue(List<QueueEntry> *queue) {
1109    while (!queue->empty()) {
1110        QueueEntry *entry = &*queue->begin();
1111
1112        if (entry->mBuffer != NULL) {
1113            entry->mNotifyConsumed->post();
1114        }
1115
1116        queue->erase(queue->begin());
1117        entry = NULL;
1118    }
1119}
1120
1121void NuPlayer::Renderer::notifyFlushComplete(bool audio) {
1122    sp<AMessage> notify = mNotify->dup();
1123    notify->setInt32("what", kWhatFlushComplete);
1124    notify->setInt32("audio", static_cast<int32_t>(audio));
1125    notify->post();
1126}
1127
1128bool NuPlayer::Renderer::dropBufferIfStale(
1129        bool audio, const sp<AMessage> &msg) {
1130    int32_t queueGeneration;
1131    CHECK(msg->findInt32("queueGeneration", &queueGeneration));
1132
1133    if (queueGeneration == getQueueGeneration(audio)) {
1134        return false;
1135    }
1136
1137    sp<AMessage> notifyConsumed;
1138    if (msg->findMessage("notifyConsumed", &notifyConsumed)) {
1139        notifyConsumed->post();
1140    }
1141
1142    return true;
1143}
1144
1145void NuPlayer::Renderer::onAudioSinkChanged() {
1146    if (offloadingAudio()) {
1147        return;
1148    }
1149    CHECK(!mDrainAudioQueuePending);
1150    mNumFramesWritten = 0;
1151    {
1152        Mutex::Autolock autoLock(mLock);
1153        mAnchorNumFramesWritten = -1;
1154    }
1155    uint32_t written;
1156    if (mAudioSink->getFramesWritten(&written) == OK) {
1157        mNumFramesWritten = written;
1158    }
1159}
1160
1161void NuPlayer::Renderer::onDisableOffloadAudio() {
1162    Mutex::Autolock autoLock(mLock);
1163    mFlags &= ~FLAG_OFFLOAD_AUDIO;
1164    ++mAudioDrainGeneration;
1165}
1166
1167void NuPlayer::Renderer::onEnableOffloadAudio() {
1168    Mutex::Autolock autoLock(mLock);
1169    mFlags |= FLAG_OFFLOAD_AUDIO;
1170    ++mAudioDrainGeneration;
1171}
1172
1173void NuPlayer::Renderer::onPause() {
1174    if (mPaused) {
1175        ALOGW("Renderer::onPause() called while already paused!");
1176        return;
1177    }
1178    int64_t currentPositionUs;
1179    {
1180        Mutex::Autolock autoLock(mLock);
1181        ++mAudioDrainGeneration;
1182        ++mVideoDrainGeneration;
1183        prepareForMediaRenderingStart_l();
1184        mPaused = true;
1185        mMediaClock->setPlaybackRate(0.0);
1186    }
1187
1188    mDrainAudioQueuePending = false;
1189    mDrainVideoQueuePending = false;
1190
1191    if (mHasAudio) {
1192        mAudioSink->pause();
1193        startAudioOffloadPauseTimeout();
1194    }
1195
1196    ALOGV("now paused audio queue has %d entries, video has %d entries",
1197          mAudioQueue.size(), mVideoQueue.size());
1198}
1199
1200void NuPlayer::Renderer::onResume() {
1201    if (!mPaused) {
1202        return;
1203    }
1204
1205    if (mHasAudio) {
1206        cancelAudioOffloadPauseTimeout();
1207        mAudioSink->start();
1208    }
1209
1210    {
1211        Mutex::Autolock autoLock(mLock);
1212        mPaused = false;
1213        mMediaClock->setPlaybackRate(mPlaybackRate);
1214
1215        if (!mAudioQueue.empty()) {
1216            postDrainAudioQueue_l();
1217        }
1218    }
1219
1220    if (!mVideoQueue.empty()) {
1221        postDrainVideoQueue();
1222    }
1223}
1224
1225void NuPlayer::Renderer::onSetVideoFrameRate(float fps) {
1226    if (mVideoScheduler == NULL) {
1227        mVideoScheduler = new VideoFrameScheduler();
1228    }
1229    mVideoScheduler->init(fps);
1230}
1231
1232int32_t NuPlayer::Renderer::getQueueGeneration(bool audio) {
1233    Mutex::Autolock autoLock(mLock);
1234    return (audio ? mAudioQueueGeneration : mVideoQueueGeneration);
1235}
1236
1237int32_t NuPlayer::Renderer::getDrainGeneration(bool audio) {
1238    Mutex::Autolock autoLock(mLock);
1239    return (audio ? mAudioDrainGeneration : mVideoDrainGeneration);
1240}
1241
1242bool NuPlayer::Renderer::getSyncQueues() {
1243    Mutex::Autolock autoLock(mLock);
1244    return mSyncQueues;
1245}
1246
1247// TODO: Remove unnecessary calls to getPlayedOutAudioDurationUs()
1248// as it acquires locks and may query the audio driver.
1249//
1250// Some calls could conceivably retrieve extrapolated data instead of
1251// accessing getTimestamp() or getPosition() every time a data buffer with
1252// a media time is received.
1253//
1254// Calculate duration of played samples if played at normal rate (i.e., 1.0).
1255int64_t NuPlayer::Renderer::getPlayedOutAudioDurationUs(int64_t nowUs) {
1256    uint32_t numFramesPlayed;
1257    int64_t numFramesPlayedAt;
1258    AudioTimestamp ts;
1259    static const int64_t kStaleTimestamp100ms = 100000;
1260
1261    status_t res = mAudioSink->getTimestamp(ts);
1262    if (res == OK) {                 // case 1: mixing audio tracks and offloaded tracks.
1263        numFramesPlayed = ts.mPosition;
1264        numFramesPlayedAt =
1265            ts.mTime.tv_sec * 1000000LL + ts.mTime.tv_nsec / 1000;
1266        const int64_t timestampAge = nowUs - numFramesPlayedAt;
1267        if (timestampAge > kStaleTimestamp100ms) {
1268            // This is an audio FIXME.
1269            // getTimestamp returns a timestamp which may come from audio mixing threads.
1270            // After pausing, the MixerThread may go idle, thus the mTime estimate may
1271            // become stale. Assuming that the MixerThread runs 20ms, with FastMixer at 5ms,
1272            // the max latency should be about 25ms with an average around 12ms (to be verified).
1273            // For safety we use 100ms.
1274            ALOGV("getTimestamp: returned stale timestamp nowUs(%lld) numFramesPlayedAt(%lld)",
1275                    (long long)nowUs, (long long)numFramesPlayedAt);
1276            numFramesPlayedAt = nowUs - kStaleTimestamp100ms;
1277        }
1278        //ALOGD("getTimestamp: OK %d %lld", numFramesPlayed, (long long)numFramesPlayedAt);
1279    } else if (res == WOULD_BLOCK) { // case 2: transitory state on start of a new track
1280        numFramesPlayed = 0;
1281        numFramesPlayedAt = nowUs;
1282        //ALOGD("getTimestamp: WOULD_BLOCK %d %lld",
1283        //        numFramesPlayed, (long long)numFramesPlayedAt);
1284    } else {                         // case 3: transitory at new track or audio fast tracks.
1285        res = mAudioSink->getPosition(&numFramesPlayed);
1286        CHECK_EQ(res, (status_t)OK);
1287        numFramesPlayedAt = nowUs;
1288        numFramesPlayedAt += 1000LL * mAudioSink->latency() / 2; /* XXX */
1289        //ALOGD("getPosition: %d %lld", numFramesPlayed, numFramesPlayedAt);
1290    }
1291
1292    //CHECK_EQ(numFramesPlayed & (1 << 31), 0);  // can't be negative until 12.4 hrs, test
1293    int64_t durationUs = getDurationUsIfPlayedAtSampleRate(numFramesPlayed)
1294            + nowUs - numFramesPlayedAt;
1295    if (durationUs < 0) {
1296        // Occurs when numFramesPlayed position is very small and the following:
1297        // (1) In case 1, the time nowUs is computed before getTimestamp() is called and
1298        //     numFramesPlayedAt is greater than nowUs by time more than numFramesPlayed.
1299        // (2) In case 3, using getPosition and adding mAudioSink->latency() to
1300        //     numFramesPlayedAt, by a time amount greater than numFramesPlayed.
1301        //
1302        // Both of these are transitory conditions.
1303        ALOGV("getPlayedOutAudioDurationUs: negative duration %lld set to zero", (long long)durationUs);
1304        durationUs = 0;
1305    }
1306    ALOGV("getPlayedOutAudioDurationUs(%lld) nowUs(%lld) frames(%u) framesAt(%lld)",
1307            (long long)durationUs, (long long)nowUs, numFramesPlayed, (long long)numFramesPlayedAt);
1308    return durationUs;
1309}
1310
1311void NuPlayer::Renderer::onAudioOffloadTearDown(AudioOffloadTearDownReason reason) {
1312    if (mAudioOffloadTornDown) {
1313        return;
1314    }
1315    mAudioOffloadTornDown = true;
1316
1317    int64_t currentPositionUs;
1318    if (getCurrentPosition(&currentPositionUs) != OK) {
1319        currentPositionUs = 0;
1320    }
1321
1322    mAudioSink->stop();
1323    mAudioSink->flush();
1324
1325    sp<AMessage> notify = mNotify->dup();
1326    notify->setInt32("what", kWhatAudioOffloadTearDown);
1327    notify->setInt64("positionUs", currentPositionUs);
1328    notify->setInt32("reason", reason);
1329    notify->post();
1330}
1331
1332void NuPlayer::Renderer::startAudioOffloadPauseTimeout() {
1333    if (offloadingAudio()) {
1334        mWakeLock->acquire();
1335        sp<AMessage> msg = new AMessage(kWhatAudioOffloadPauseTimeout, this);
1336        msg->setInt32("drainGeneration", mAudioOffloadPauseTimeoutGeneration);
1337        msg->post(kOffloadPauseMaxUs);
1338    }
1339}
1340
1341void NuPlayer::Renderer::cancelAudioOffloadPauseTimeout() {
1342    if (offloadingAudio()) {
1343        mWakeLock->release(true);
1344        ++mAudioOffloadPauseTimeoutGeneration;
1345    }
1346}
1347
1348status_t NuPlayer::Renderer::onOpenAudioSink(
1349        const sp<AMessage> &format,
1350        bool offloadOnly,
1351        bool hasVideo,
1352        uint32_t flags) {
1353    ALOGV("openAudioSink: offloadOnly(%d) offloadingAudio(%d)",
1354            offloadOnly, offloadingAudio());
1355    bool audioSinkChanged = false;
1356
1357    int32_t numChannels;
1358    CHECK(format->findInt32("channel-count", &numChannels));
1359
1360    int32_t channelMask;
1361    if (!format->findInt32("channel-mask", &channelMask)) {
1362        // signal to the AudioSink to derive the mask from count.
1363        channelMask = CHANNEL_MASK_USE_CHANNEL_ORDER;
1364    }
1365
1366    int32_t sampleRate;
1367    CHECK(format->findInt32("sample-rate", &sampleRate));
1368
1369    if (offloadingAudio()) {
1370        audio_format_t audioFormat = AUDIO_FORMAT_PCM_16_BIT;
1371        AString mime;
1372        CHECK(format->findString("mime", &mime));
1373        status_t err = mapMimeToAudioFormat(audioFormat, mime.c_str());
1374
1375        if (err != OK) {
1376            ALOGE("Couldn't map mime \"%s\" to a valid "
1377                    "audio_format", mime.c_str());
1378            onDisableOffloadAudio();
1379        } else {
1380            ALOGV("Mime \"%s\" mapped to audio_format 0x%x",
1381                    mime.c_str(), audioFormat);
1382
1383            int avgBitRate = -1;
1384            format->findInt32("bit-rate", &avgBitRate);
1385
1386            int32_t aacProfile = -1;
1387            if (audioFormat == AUDIO_FORMAT_AAC
1388                    && format->findInt32("aac-profile", &aacProfile)) {
1389                // Redefine AAC format as per aac profile
1390                mapAACProfileToAudioFormat(
1391                        audioFormat,
1392                        aacProfile);
1393            }
1394
1395            audio_offload_info_t offloadInfo = AUDIO_INFO_INITIALIZER;
1396            offloadInfo.duration_us = -1;
1397            format->findInt64(
1398                    "durationUs", &offloadInfo.duration_us);
1399            offloadInfo.sample_rate = sampleRate;
1400            offloadInfo.channel_mask = channelMask;
1401            offloadInfo.format = audioFormat;
1402            offloadInfo.stream_type = AUDIO_STREAM_MUSIC;
1403            offloadInfo.bit_rate = avgBitRate;
1404            offloadInfo.has_video = hasVideo;
1405            offloadInfo.is_streaming = true;
1406
1407            if (memcmp(&mCurrentOffloadInfo, &offloadInfo, sizeof(offloadInfo)) == 0) {
1408                ALOGV("openAudioSink: no change in offload mode");
1409                // no change from previous configuration, everything ok.
1410                return OK;
1411            }
1412            mCurrentPcmInfo = AUDIO_PCMINFO_INITIALIZER;
1413
1414            ALOGV("openAudioSink: try to open AudioSink in offload mode");
1415            uint32_t offloadFlags = flags;
1416            offloadFlags |= AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD;
1417            offloadFlags &= ~AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
1418            audioSinkChanged = true;
1419            mAudioSink->close();
1420            err = mAudioSink->open(
1421                    sampleRate,
1422                    numChannels,
1423                    (audio_channel_mask_t)channelMask,
1424                    audioFormat,
1425                    8 /* bufferCount */,
1426                    &NuPlayer::Renderer::AudioSinkCallback,
1427                    this,
1428                    (audio_output_flags_t)offloadFlags,
1429                    &offloadInfo);
1430
1431            if (err == OK) {
1432                if (mPlaybackRate != 1.0) {
1433                    mAudioSink->setPlaybackRatePermille(
1434                            (int32_t)(mPlaybackRate * 1000 + 0.5f));
1435                }
1436                // If the playback is offloaded to h/w, we pass
1437                // the HAL some metadata information.
1438                // We don't want to do this for PCM because it
1439                // will be going through the AudioFlinger mixer
1440                // before reaching the hardware.
1441                // TODO
1442                mCurrentOffloadInfo = offloadInfo;
1443                err = mAudioSink->start();
1444                ALOGV_IF(err == OK, "openAudioSink: offload succeeded");
1445            }
1446            if (err != OK) {
1447                // Clean up, fall back to non offload mode.
1448                mAudioSink->close();
1449                onDisableOffloadAudio();
1450                mCurrentOffloadInfo = AUDIO_INFO_INITIALIZER;
1451                ALOGV("openAudioSink: offload failed");
1452            }
1453        }
1454    }
1455    if (!offloadOnly && !offloadingAudio()) {
1456        ALOGV("openAudioSink: open AudioSink in NON-offload mode");
1457        uint32_t pcmFlags = flags;
1458        pcmFlags &= ~AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD;
1459
1460        const PcmInfo info = {
1461                (audio_channel_mask_t)channelMask,
1462                (audio_output_flags_t)pcmFlags,
1463                AUDIO_FORMAT_PCM_16_BIT, // TODO: change to audioFormat
1464                numChannels,
1465                sampleRate
1466        };
1467        if (memcmp(&mCurrentPcmInfo, &info, sizeof(info)) == 0) {
1468            ALOGV("openAudioSink: no change in pcm mode");
1469            // no change from previous configuration, everything ok.
1470            return OK;
1471        }
1472
1473        audioSinkChanged = true;
1474        mAudioSink->close();
1475        mCurrentOffloadInfo = AUDIO_INFO_INITIALIZER;
1476        status_t err = mAudioSink->open(
1477                    sampleRate,
1478                    numChannels,
1479                    (audio_channel_mask_t)channelMask,
1480                    AUDIO_FORMAT_PCM_16_BIT,
1481                    8 /* bufferCount */,
1482                    NULL,
1483                    NULL,
1484                    (audio_output_flags_t)pcmFlags);
1485        if (err != OK) {
1486            ALOGW("openAudioSink: non offloaded open failed status: %d", err);
1487            mCurrentPcmInfo = AUDIO_PCMINFO_INITIALIZER;
1488            return err;
1489        }
1490        mCurrentPcmInfo = info;
1491        if (mPlaybackRate != 1.0) {
1492            mAudioSink->setPlaybackRatePermille(
1493                    (int32_t)(mPlaybackRate * 1000 + 0.5f));
1494        }
1495        mAudioSink->start();
1496    }
1497    if (audioSinkChanged) {
1498        onAudioSinkChanged();
1499    }
1500    if (offloadingAudio()) {
1501        mAudioOffloadTornDown = false;
1502    }
1503    return OK;
1504}
1505
1506void NuPlayer::Renderer::onCloseAudioSink() {
1507    mAudioSink->close();
1508    mCurrentOffloadInfo = AUDIO_INFO_INITIALIZER;
1509    mCurrentPcmInfo = AUDIO_PCMINFO_INITIALIZER;
1510}
1511
1512}  // namespace android
1513
1514