NuPlayerDriver.cpp revision aaa4dfa3c854523b2935b7958d4c4a24498b7ce3 
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 "NuPlayerDriver"
19#include <inttypes.h>
20#include <utils/Log.h>
21#include <cutils/properties.h>
22
23#include "NuPlayerDriver.h"
24
25#include "NuPlayer.h"
26#include "NuPlayerSource.h"
27
28#include <media/stagefright/foundation/ADebug.h>
29#include <media/stagefright/foundation/ALooper.h>
30#include <media/stagefright/foundation/AUtils.h>
31#include <media/stagefright/MetaData.h>
32#include <media/stagefright/Utils.h>
33
34#include <media/IMediaAnalyticsService.h>
35
36static const int kDumpLockRetries = 50;
37static const int kDumpLockSleepUs = 20000;
38
39namespace android {
40
41
42NuPlayerDriver::NuPlayerDriver(pid_t pid)
43    : mState(STATE_IDLE),
44      mIsAsyncPrepare(false),
45      mAsyncResult(UNKNOWN_ERROR),
46      mSetSurfaceInProgress(false),
47      mDurationUs(-1),
48      mPositionUs(-1),
49      mSeekInProgress(false),
50      mPlayingTimeUs(0),
51      mLooper(new ALooper),
52      mPlayerFlags(0),
53      mAnalyticsItem(NULL),
54      mAtEOS(false),
55      mLooping(false),
56      mAutoLoop(false) {
57    ALOGD("NuPlayerDriver(%p) created, clientPid(%d)", this, pid);
58    mLooper->setName("NuPlayerDriver Looper");
59
60    // set up an analytics record
61    mAnalyticsItem = new MediaAnalyticsItem("nuplayer");
62    mAnalyticsItem->generateSessionID();
63
64    mLooper->start(
65            false, /* runOnCallingThread */
66            true,  /* canCallJava */
67            PRIORITY_AUDIO);
68
69    mPlayer = new NuPlayer(pid);
70    mLooper->registerHandler(mPlayer);
71
72    mPlayer->setDriver(this);
73}
74
75NuPlayerDriver::~NuPlayerDriver() {
76    ALOGV("~NuPlayerDriver(%p)", this);
77    mLooper->stop();
78
79    // finalize any pending metrics, usually a no-op.
80    finalizeMetrics("destructor");
81    logMetrics("destructor");
82
83    if (mAnalyticsItem != NULL) {
84        delete mAnalyticsItem;
85        mAnalyticsItem = NULL;
86    }
87}
88
89status_t NuPlayerDriver::initCheck() {
90    return OK;
91}
92
93status_t NuPlayerDriver::setUID(uid_t uid) {
94    mPlayer->setUID(uid);
95
96    return OK;
97}
98
99status_t NuPlayerDriver::setDataSource(
100        const sp<IMediaHTTPService> &httpService,
101        const char *url,
102        const KeyedVector<String8, String8> *headers) {
103    ALOGV("setDataSource(%p) url(%s)", this, uriDebugString(url, false).c_str());
104    Mutex::Autolock autoLock(mLock);
105
106    if (mState != STATE_IDLE) {
107        return INVALID_OPERATION;
108    }
109
110    mState = STATE_SET_DATASOURCE_PENDING;
111
112    mPlayer->setDataSourceAsync(httpService, url, headers);
113
114    while (mState == STATE_SET_DATASOURCE_PENDING) {
115        mCondition.wait(mLock);
116    }
117
118    return mAsyncResult;
119}
120
121status_t NuPlayerDriver::setDataSource(int fd, int64_t offset, int64_t length) {
122    ALOGV("setDataSource(%p) file(%d)", this, fd);
123    Mutex::Autolock autoLock(mLock);
124
125    if (mState != STATE_IDLE) {
126        return INVALID_OPERATION;
127    }
128
129    mState = STATE_SET_DATASOURCE_PENDING;
130
131    mPlayer->setDataSourceAsync(fd, offset, length);
132
133    while (mState == STATE_SET_DATASOURCE_PENDING) {
134        mCondition.wait(mLock);
135    }
136
137    return mAsyncResult;
138}
139
140status_t NuPlayerDriver::setDataSource(const sp<IStreamSource> &source) {
141    ALOGV("setDataSource(%p) stream source", this);
142    Mutex::Autolock autoLock(mLock);
143
144    if (mState != STATE_IDLE) {
145        return INVALID_OPERATION;
146    }
147
148    mState = STATE_SET_DATASOURCE_PENDING;
149
150    mPlayer->setDataSourceAsync(source);
151
152    while (mState == STATE_SET_DATASOURCE_PENDING) {
153        mCondition.wait(mLock);
154    }
155
156    return mAsyncResult;
157}
158
159status_t NuPlayerDriver::setDataSource(const sp<DataSource> &source) {
160    ALOGV("setDataSource(%p) callback source", this);
161    Mutex::Autolock autoLock(mLock);
162
163    if (mState != STATE_IDLE) {
164        return INVALID_OPERATION;
165    }
166
167    mState = STATE_SET_DATASOURCE_PENDING;
168
169    mPlayer->setDataSourceAsync(source);
170
171    while (mState == STATE_SET_DATASOURCE_PENDING) {
172        mCondition.wait(mLock);
173    }
174
175    return mAsyncResult;
176}
177
178status_t NuPlayerDriver::setVideoSurfaceTexture(
179        const sp<IGraphicBufferProducer> &bufferProducer) {
180    ALOGV("setVideoSurfaceTexture(%p)", this);
181    Mutex::Autolock autoLock(mLock);
182
183    if (mSetSurfaceInProgress) {
184        return INVALID_OPERATION;
185    }
186
187    switch (mState) {
188        case STATE_SET_DATASOURCE_PENDING:
189        case STATE_RESET_IN_PROGRESS:
190            return INVALID_OPERATION;
191
192        default:
193            break;
194    }
195
196    mSetSurfaceInProgress = true;
197
198    mPlayer->setVideoSurfaceTextureAsync(bufferProducer);
199
200    while (mSetSurfaceInProgress) {
201        mCondition.wait(mLock);
202    }
203
204    return OK;
205}
206
207status_t NuPlayerDriver::getDefaultBufferingSettings(BufferingSettings* buffering) {
208    ALOGV("getDefaultBufferingSettings(%p)", this);
209    {
210        Mutex::Autolock autoLock(mLock);
211        if (mState == STATE_IDLE) {
212            return INVALID_OPERATION;
213        }
214    }
215
216    return mPlayer->getDefaultBufferingSettings(buffering);
217}
218
219status_t NuPlayerDriver::setBufferingSettings(const BufferingSettings& buffering) {
220    ALOGV("setBufferingSettings(%p)", this);
221    {
222        Mutex::Autolock autoLock(mLock);
223        if (mState == STATE_IDLE) {
224            return INVALID_OPERATION;
225        }
226    }
227
228    return mPlayer->setBufferingSettings(buffering);
229}
230
231status_t NuPlayerDriver::prepare() {
232    ALOGV("prepare(%p)", this);
233    Mutex::Autolock autoLock(mLock);
234    return prepare_l();
235}
236
237status_t NuPlayerDriver::prepare_l() {
238    switch (mState) {
239        case STATE_UNPREPARED:
240            mState = STATE_PREPARING;
241
242            // Make sure we're not posting any notifications, success or
243            // failure information is only communicated through our result
244            // code.
245            mIsAsyncPrepare = false;
246            mPlayer->prepareAsync();
247            while (mState == STATE_PREPARING) {
248                mCondition.wait(mLock);
249            }
250            return (mState == STATE_PREPARED) ? OK : UNKNOWN_ERROR;
251        case STATE_STOPPED:
252            // this is really just paused. handle as seek to start
253            mAtEOS = false;
254            mState = STATE_STOPPED_AND_PREPARING;
255            mIsAsyncPrepare = false;
256            mPlayer->seekToAsync(0, MediaPlayerSeekMode::SEEK_PREVIOUS_SYNC /* mode */,
257                    true /* needNotify */);
258            while (mState == STATE_STOPPED_AND_PREPARING) {
259                mCondition.wait(mLock);
260            }
261            return (mState == STATE_STOPPED_AND_PREPARED) ? OK : UNKNOWN_ERROR;
262        default:
263            return INVALID_OPERATION;
264    };
265}
266
267status_t NuPlayerDriver::prepareAsync() {
268    ALOGV("prepareAsync(%p)", this);
269    Mutex::Autolock autoLock(mLock);
270
271    switch (mState) {
272        case STATE_UNPREPARED:
273            mState = STATE_PREPARING;
274            mIsAsyncPrepare = true;
275            mPlayer->prepareAsync();
276            return OK;
277        case STATE_STOPPED:
278            // this is really just paused. handle as seek to start
279            mAtEOS = false;
280            mState = STATE_STOPPED_AND_PREPARING;
281            mIsAsyncPrepare = true;
282            mPlayer->seekToAsync(0, MediaPlayerSeekMode::SEEK_PREVIOUS_SYNC /* mode */,
283                    true /* needNotify */);
284            return OK;
285        default:
286            return INVALID_OPERATION;
287    };
288}
289
290status_t NuPlayerDriver::start() {
291    ALOGD("start(%p), state is %d, eos is %d", this, mState, mAtEOS);
292    Mutex::Autolock autoLock(mLock);
293    return start_l();
294}
295
296status_t NuPlayerDriver::start_l() {
297    switch (mState) {
298        case STATE_UNPREPARED:
299        {
300            status_t err = prepare_l();
301
302            if (err != OK) {
303                return err;
304            }
305
306            CHECK_EQ(mState, STATE_PREPARED);
307
308            // fall through
309        }
310
311        case STATE_PAUSED:
312        case STATE_STOPPED_AND_PREPARED:
313        case STATE_PREPARED:
314        {
315            mPlayer->start();
316
317            // fall through
318        }
319
320        case STATE_RUNNING:
321        {
322            if (mAtEOS) {
323                mPlayer->seekToAsync(0);
324                mAtEOS = false;
325                mPositionUs = -1;
326            }
327            break;
328        }
329
330        default:
331            return INVALID_OPERATION;
332    }
333
334    mState = STATE_RUNNING;
335
336    return OK;
337}
338
339status_t NuPlayerDriver::stop() {
340    ALOGD("stop(%p)", this);
341    Mutex::Autolock autoLock(mLock);
342
343    switch (mState) {
344        case STATE_RUNNING:
345            mPlayer->pause();
346            // fall through
347
348        case STATE_PAUSED:
349            mState = STATE_STOPPED;
350            notifyListener_l(MEDIA_STOPPED);
351            break;
352
353        case STATE_PREPARED:
354        case STATE_STOPPED:
355        case STATE_STOPPED_AND_PREPARING:
356        case STATE_STOPPED_AND_PREPARED:
357            mState = STATE_STOPPED;
358            break;
359
360        default:
361            return INVALID_OPERATION;
362    }
363
364    return OK;
365}
366
367status_t NuPlayerDriver::pause() {
368    ALOGD("pause(%p)", this);
369    // The NuPlayerRenderer may get flushed if pause for long enough, e.g. the pause timeout tear
370    // down for audio offload mode. If that happens, the NuPlayerRenderer will no longer know the
371    // current position. So similar to seekTo, update |mPositionUs| to the pause position by calling
372    // getCurrentPosition here.
373    int unused;
374    getCurrentPosition(&unused);
375
376    Mutex::Autolock autoLock(mLock);
377
378    switch (mState) {
379        case STATE_PAUSED:
380        case STATE_PREPARED:
381            return OK;
382
383        case STATE_RUNNING:
384            mState = STATE_PAUSED;
385            notifyListener_l(MEDIA_PAUSED);
386            mPlayer->pause();
387            break;
388
389        default:
390            return INVALID_OPERATION;
391    }
392
393    return OK;
394}
395
396bool NuPlayerDriver::isPlaying() {
397    return mState == STATE_RUNNING && !mAtEOS;
398}
399
400status_t NuPlayerDriver::setPlaybackSettings(const AudioPlaybackRate &rate) {
401    status_t err = mPlayer->setPlaybackSettings(rate);
402    if (err == OK) {
403        // try to update position
404        int unused;
405        getCurrentPosition(&unused);
406        Mutex::Autolock autoLock(mLock);
407        if (rate.mSpeed == 0.f && mState == STATE_RUNNING) {
408            mState = STATE_PAUSED;
409            notifyListener_l(MEDIA_PAUSED);
410        } else if (rate.mSpeed != 0.f
411                && (mState == STATE_PAUSED
412                    || mState == STATE_STOPPED_AND_PREPARED
413                    || mState == STATE_PREPARED)) {
414            err = start_l();
415        }
416    }
417    return err;
418}
419
420status_t NuPlayerDriver::getPlaybackSettings(AudioPlaybackRate *rate) {
421    return mPlayer->getPlaybackSettings(rate);
422}
423
424status_t NuPlayerDriver::setSyncSettings(const AVSyncSettings &sync, float videoFpsHint) {
425    return mPlayer->setSyncSettings(sync, videoFpsHint);
426}
427
428status_t NuPlayerDriver::getSyncSettings(AVSyncSettings *sync, float *videoFps) {
429    return mPlayer->getSyncSettings(sync, videoFps);
430}
431
432status_t NuPlayerDriver::seekTo(int msec, MediaPlayerSeekMode mode) {
433    ALOGD("seekTo(%p) (%d ms, %d) at state %d", this, msec, mode, mState);
434    Mutex::Autolock autoLock(mLock);
435
436    int64_t seekTimeUs = msec * 1000ll;
437
438    switch (mState) {
439        case STATE_PREPARED:
440        case STATE_STOPPED_AND_PREPARED:
441        case STATE_PAUSED:
442        case STATE_RUNNING:
443        {
444            mAtEOS = false;
445            mSeekInProgress = true;
446            // seeks can take a while, so we essentially paused
447            notifyListener_l(MEDIA_PAUSED);
448            mPlayer->seekToAsync(seekTimeUs, mode, true /* needNotify */);
449            break;
450        }
451
452        default:
453            return INVALID_OPERATION;
454    }
455
456    mPositionUs = seekTimeUs;
457    return OK;
458}
459
460status_t NuPlayerDriver::getCurrentPosition(int *msec) {
461    int64_t tempUs = 0;
462    {
463        Mutex::Autolock autoLock(mLock);
464        if (mSeekInProgress || (mState == STATE_PAUSED && !mAtEOS)) {
465            tempUs = (mPositionUs <= 0) ? 0 : mPositionUs;
466            *msec = (int)divRound(tempUs, (int64_t)(1000));
467            return OK;
468        }
469    }
470
471    status_t ret = mPlayer->getCurrentPosition(&tempUs);
472
473    Mutex::Autolock autoLock(mLock);
474    // We need to check mSeekInProgress here because mPlayer->seekToAsync is an async call, which
475    // means getCurrentPosition can be called before seek is completed. Iow, renderer may return a
476    // position value that's different the seek to position.
477    if (ret != OK) {
478        tempUs = (mPositionUs <= 0) ? 0 : mPositionUs;
479    } else {
480        mPositionUs = tempUs;
481    }
482    *msec = (int)divRound(tempUs, (int64_t)(1000));
483    return OK;
484}
485
486status_t NuPlayerDriver::getDuration(int *msec) {
487    Mutex::Autolock autoLock(mLock);
488
489    if (mDurationUs < 0) {
490        return UNKNOWN_ERROR;
491    }
492
493    *msec = (mDurationUs + 500ll) / 1000;
494
495    return OK;
496}
497
498void NuPlayerDriver::finalizeMetrics(const char *where) {
499    if (where == NULL) {
500        where = "unknown";
501    }
502    ALOGD("finalizeMetrics(%p) from %s at state %d", this, where, mState);
503
504    // gather the final stats for this record
505    Vector<sp<AMessage>> trackStats;
506    mPlayer->getStats(&trackStats);
507
508    if (trackStats.size() > 0) {
509        for (size_t i = 0; i < trackStats.size(); ++i) {
510            const sp<AMessage> &stats = trackStats.itemAt(i);
511
512            AString mime;
513            stats->findString("mime", &mime);
514
515            AString name;
516            stats->findString("component-name", &name);
517
518            if (mime.startsWith("video/")) {
519                int32_t width, height;
520                mAnalyticsItem->setCString("video/mime", mime.c_str());
521                if (!name.empty()) {
522                    mAnalyticsItem->setCString("video/codec", name.c_str());
523                }
524
525                if (stats->findInt32("width", &width)
526                        && stats->findInt32("height", &height)) {
527                    mAnalyticsItem->setInt32("wid", width);
528                    mAnalyticsItem->setInt32("ht", height);
529                }
530
531                int64_t numFramesTotal = 0;
532                int64_t numFramesDropped = 0;
533                stats->findInt64("frames-total", &numFramesTotal);
534                stats->findInt64("frames-dropped-output", &numFramesDropped);
535
536                mAnalyticsItem->setInt64("frames", numFramesTotal);
537                mAnalyticsItem->setInt64("dropped", numFramesDropped);
538
539
540            } else if (mime.startsWith("audio/")) {
541                mAnalyticsItem->setCString("audio/mime", mime.c_str());
542                if (!name.empty()) {
543                    mAnalyticsItem->setCString("audio/codec", name.c_str());
544                }
545            }
546        }
547
548        // getDuration() uses mLock for mutex -- careful where we use it.
549        int duration_ms = -1;
550        getDuration(&duration_ms);
551        if (duration_ms != -1) {
552            mAnalyticsItem->setInt64("duration", duration_ms);
553        }
554
555        if (mPlayingTimeUs > 0) {
556            mAnalyticsItem->setInt64("playing", (mPlayingTimeUs+500)/1000 );
557        }
558    }
559}
560
561
562void NuPlayerDriver::logMetrics(const char *where) {
563    if (where == NULL) {
564        where = "unknown";
565    }
566    ALOGD("logMetrics(%p) from %s at state %d", this, where, mState);
567
568    if (mAnalyticsItem == NULL || mAnalyticsItem->isEnabled() == false) {
569        return;
570    }
571
572    // only bother to log non-empty records
573    if (mAnalyticsItem->count() > 0) {
574
575        mAnalyticsItem->setFinalized(true);
576        mAnalyticsItem->selfrecord();
577
578        // re-init in case we prepare() and start() again.
579        delete mAnalyticsItem ;
580        mAnalyticsItem = new MediaAnalyticsItem("nuplayer");
581        if (mAnalyticsItem) {
582            mAnalyticsItem->generateSessionID();
583        }
584    } else {
585        ALOGV("did not have anything to record");
586    }
587}
588
589status_t NuPlayerDriver::reset() {
590    ALOGD("reset(%p) at state %d", this, mState);
591
592    finalizeMetrics("reset");
593    logMetrics("reset");
594
595    Mutex::Autolock autoLock(mLock);
596
597    switch (mState) {
598        case STATE_IDLE:
599            return OK;
600
601        case STATE_SET_DATASOURCE_PENDING:
602        case STATE_RESET_IN_PROGRESS:
603            return INVALID_OPERATION;
604
605        case STATE_PREPARING:
606        {
607            CHECK(mIsAsyncPrepare);
608
609            notifyListener_l(MEDIA_PREPARED);
610            break;
611        }
612
613        default:
614            break;
615    }
616
617    if (mState != STATE_STOPPED) {
618        notifyListener_l(MEDIA_STOPPED);
619    }
620
621    if (property_get_bool("persist.debug.sf.stats", false)) {
622        Vector<String16> args;
623        dump(-1, args);
624    }
625
626    mState = STATE_RESET_IN_PROGRESS;
627    mPlayer->resetAsync();
628
629    while (mState == STATE_RESET_IN_PROGRESS) {
630        mCondition.wait(mLock);
631    }
632
633    mDurationUs = -1;
634    mPositionUs = -1;
635    mLooping = false;
636    mPlayingTimeUs = 0;
637
638    return OK;
639}
640
641status_t NuPlayerDriver::setLooping(int loop) {
642    mLooping = loop != 0;
643    return OK;
644}
645
646player_type NuPlayerDriver::playerType() {
647    return NU_PLAYER;
648}
649
650status_t NuPlayerDriver::invoke(const Parcel &request, Parcel *reply) {
651    if (reply == NULL) {
652        ALOGE("reply is a NULL pointer");
653        return BAD_VALUE;
654    }
655
656    int32_t methodId;
657    status_t ret = request.readInt32(&methodId);
658    if (ret != OK) {
659        ALOGE("Failed to retrieve the requested method to invoke");
660        return ret;
661    }
662
663    switch (methodId) {
664        case INVOKE_ID_SET_VIDEO_SCALING_MODE:
665        {
666            int mode = request.readInt32();
667            return mPlayer->setVideoScalingMode(mode);
668        }
669
670        case INVOKE_ID_GET_TRACK_INFO:
671        {
672            return mPlayer->getTrackInfo(reply);
673        }
674
675        case INVOKE_ID_SELECT_TRACK:
676        {
677            int trackIndex = request.readInt32();
678            int msec = 0;
679            // getCurrentPosition should always return OK
680            getCurrentPosition(&msec);
681            return mPlayer->selectTrack(trackIndex, true /* select */, msec * 1000ll);
682        }
683
684        case INVOKE_ID_UNSELECT_TRACK:
685        {
686            int trackIndex = request.readInt32();
687            return mPlayer->selectTrack(trackIndex, false /* select */, 0xdeadbeef /* not used */);
688        }
689
690        case INVOKE_ID_GET_SELECTED_TRACK:
691        {
692            int32_t type = request.readInt32();
693            return mPlayer->getSelectedTrack(type, reply);
694        }
695
696        default:
697        {
698            return INVALID_OPERATION;
699        }
700    }
701}
702
703void NuPlayerDriver::setAudioSink(const sp<AudioSink> &audioSink) {
704    mPlayer->setAudioSink(audioSink);
705    mAudioSink = audioSink;
706}
707
708status_t NuPlayerDriver::setParameter(
709        int /* key */, const Parcel & /* request */) {
710    return INVALID_OPERATION;
711}
712
713status_t NuPlayerDriver::getParameter(int key, Parcel *reply) {
714
715    if (key == FOURCC('m','t','r','X')) {
716        // mtrX -- a play on 'metrics' (not matrix)
717        // gather current info all together, parcel it, and send it back
718        finalizeMetrics("api");
719        mAnalyticsItem->writeToParcel(reply);
720        return OK;
721    }
722
723    return INVALID_OPERATION;
724}
725
726status_t NuPlayerDriver::getMetadata(
727        const media::Metadata::Filter& /* ids */, Parcel *records) {
728    Mutex::Autolock autoLock(mLock);
729
730    using media::Metadata;
731
732    Metadata meta(records);
733
734    meta.appendBool(
735            Metadata::kPauseAvailable,
736            mPlayerFlags & NuPlayer::Source::FLAG_CAN_PAUSE);
737
738    meta.appendBool(
739            Metadata::kSeekBackwardAvailable,
740            mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_BACKWARD);
741
742    meta.appendBool(
743            Metadata::kSeekForwardAvailable,
744            mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_FORWARD);
745
746    meta.appendBool(
747            Metadata::kSeekAvailable,
748            mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK);
749
750    return OK;
751}
752
753void NuPlayerDriver::notifyResetComplete() {
754    ALOGD("notifyResetComplete(%p)", this);
755    Mutex::Autolock autoLock(mLock);
756
757    CHECK_EQ(mState, STATE_RESET_IN_PROGRESS);
758    mState = STATE_IDLE;
759    mCondition.broadcast();
760}
761
762void NuPlayerDriver::notifySetSurfaceComplete() {
763    ALOGV("notifySetSurfaceComplete(%p)", this);
764    Mutex::Autolock autoLock(mLock);
765
766    CHECK(mSetSurfaceInProgress);
767    mSetSurfaceInProgress = false;
768
769    mCondition.broadcast();
770}
771
772void NuPlayerDriver::notifyDuration(int64_t durationUs) {
773    Mutex::Autolock autoLock(mLock);
774    mDurationUs = durationUs;
775}
776
777void NuPlayerDriver::notifyMorePlayingTimeUs(int64_t playingUs) {
778    Mutex::Autolock autoLock(mLock);
779    mPlayingTimeUs += playingUs;
780}
781
782void NuPlayerDriver::notifySeekComplete() {
783    ALOGV("notifySeekComplete(%p)", this);
784    Mutex::Autolock autoLock(mLock);
785    mSeekInProgress = false;
786    notifySeekComplete_l();
787}
788
789void NuPlayerDriver::notifySeekComplete_l() {
790    bool wasSeeking = true;
791    if (mState == STATE_STOPPED_AND_PREPARING) {
792        wasSeeking = false;
793        mState = STATE_STOPPED_AND_PREPARED;
794        mCondition.broadcast();
795        if (!mIsAsyncPrepare) {
796            // if we are preparing synchronously, no need to notify listener
797            return;
798        }
799    } else if (mState == STATE_STOPPED) {
800        // no need to notify listener
801        return;
802    }
803    notifyListener_l(wasSeeking ? MEDIA_SEEK_COMPLETE : MEDIA_PREPARED);
804}
805
806status_t NuPlayerDriver::dump(
807        int fd, const Vector<String16> & /* args */) const {
808
809    Vector<sp<AMessage> > trackStats;
810    mPlayer->getStats(&trackStats);
811
812    AString logString(" NuPlayer\n");
813    char buf[256] = {0};
814
815    bool locked = false;
816    for (int i = 0; i < kDumpLockRetries; ++i) {
817        if (mLock.tryLock() == NO_ERROR) {
818            locked = true;
819            break;
820        }
821        usleep(kDumpLockSleepUs);
822    }
823
824    if (locked) {
825        snprintf(buf, sizeof(buf), "  state(%d), atEOS(%d), looping(%d), autoLoop(%d)\n",
826                mState, mAtEOS, mLooping, mAutoLoop);
827        mLock.unlock();
828    } else {
829        snprintf(buf, sizeof(buf), "  NPD(%p) lock is taken\n", this);
830    }
831    logString.append(buf);
832
833    for (size_t i = 0; i < trackStats.size(); ++i) {
834        const sp<AMessage> &stats = trackStats.itemAt(i);
835
836        AString mime;
837        if (stats->findString("mime", &mime)) {
838            snprintf(buf, sizeof(buf), "  mime(%s)\n", mime.c_str());
839            logString.append(buf);
840        }
841
842        AString name;
843        if (stats->findString("component-name", &name)) {
844            snprintf(buf, sizeof(buf), "    decoder(%s)\n", name.c_str());
845            logString.append(buf);
846        }
847
848        if (mime.startsWith("video/")) {
849            int32_t width, height;
850            if (stats->findInt32("width", &width)
851                    && stats->findInt32("height", &height)) {
852                snprintf(buf, sizeof(buf), "    resolution(%d x %d)\n", width, height);
853                logString.append(buf);
854            }
855
856            int64_t numFramesTotal = 0;
857            int64_t numFramesDropped = 0;
858
859            stats->findInt64("frames-total", &numFramesTotal);
860            stats->findInt64("frames-dropped-output", &numFramesDropped);
861            snprintf(buf, sizeof(buf), "    numFramesTotal(%lld), numFramesDropped(%lld), "
862                     "percentageDropped(%.2f%%)\n",
863                     (long long)numFramesTotal,
864                     (long long)numFramesDropped,
865                     numFramesTotal == 0
866                            ? 0.0 : (double)(numFramesDropped * 100) / numFramesTotal);
867            logString.append(buf);
868        }
869    }
870
871    ALOGI("%s", logString.c_str());
872
873    if (fd >= 0) {
874        FILE *out = fdopen(dup(fd), "w");
875        fprintf(out, "%s", logString.c_str());
876        fclose(out);
877        out = NULL;
878    }
879
880    return OK;
881}
882
883void NuPlayerDriver::notifyListener(
884        int msg, int ext1, int ext2, const Parcel *in) {
885    Mutex::Autolock autoLock(mLock);
886    notifyListener_l(msg, ext1, ext2, in);
887}
888
889void NuPlayerDriver::notifyListener_l(
890        int msg, int ext1, int ext2, const Parcel *in) {
891    ALOGD("notifyListener_l(%p), (%d, %d, %d), loop setting(%d, %d)",
892            this, msg, ext1, ext2, mAutoLoop, mLooping);
893    switch (msg) {
894        case MEDIA_PLAYBACK_COMPLETE:
895        {
896            if (mState != STATE_RESET_IN_PROGRESS) {
897                if (mAutoLoop) {
898                    audio_stream_type_t streamType = AUDIO_STREAM_MUSIC;
899                    if (mAudioSink != NULL) {
900                        streamType = mAudioSink->getAudioStreamType();
901                    }
902                    if (streamType == AUDIO_STREAM_NOTIFICATION) {
903                        ALOGW("disabling auto-loop for notification");
904                        mAutoLoop = false;
905                    }
906                }
907                if (mLooping || mAutoLoop) {
908                    mPlayer->seekToAsync(0);
909                    if (mAudioSink != NULL) {
910                        // The renderer has stopped the sink at the end in order to play out
911                        // the last little bit of audio. If we're looping, we need to restart it.
912                        mAudioSink->start();
913                    }
914                    // don't send completion event when looping
915                    return;
916                }
917
918                mPlayer->pause();
919                mState = STATE_PAUSED;
920            }
921            // fall through
922        }
923
924        case MEDIA_ERROR:
925        {
926            mAtEOS = true;
927            break;
928        }
929
930        default:
931            break;
932    }
933
934    mLock.unlock();
935    sendEvent(msg, ext1, ext2, in);
936    mLock.lock();
937}
938
939void NuPlayerDriver::notifySetDataSourceCompleted(status_t err) {
940    Mutex::Autolock autoLock(mLock);
941
942    CHECK_EQ(mState, STATE_SET_DATASOURCE_PENDING);
943
944    mAsyncResult = err;
945    mState = (err == OK) ? STATE_UNPREPARED : STATE_IDLE;
946    mCondition.broadcast();
947}
948
949void NuPlayerDriver::notifyPrepareCompleted(status_t err) {
950    Mutex::Autolock autoLock(mLock);
951
952    if (mState != STATE_PREPARING) {
953        // We were preparing asynchronously when the client called
954        // reset(), we sent a premature "prepared" notification and
955        // then initiated the reset. This notification is stale.
956        CHECK(mState == STATE_RESET_IN_PROGRESS || mState == STATE_IDLE);
957        return;
958    }
959
960    CHECK_EQ(mState, STATE_PREPARING);
961
962    mAsyncResult = err;
963
964    if (err == OK) {
965        // update state before notifying client, so that if client calls back into NuPlayerDriver
966        // in response, NuPlayerDriver has the right state
967        mState = STATE_PREPARED;
968        if (mIsAsyncPrepare) {
969            notifyListener_l(MEDIA_PREPARED);
970        }
971    } else {
972        mState = STATE_UNPREPARED;
973        if (mIsAsyncPrepare) {
974            notifyListener_l(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
975        }
976    }
977
978    sp<MetaData> meta = mPlayer->getFileMeta();
979    int32_t loop;
980    if (meta != NULL
981            && meta->findInt32(kKeyAutoLoop, &loop) && loop != 0) {
982        mAutoLoop = true;
983    }
984
985    mCondition.broadcast();
986}
987
988void NuPlayerDriver::notifyFlagsChanged(uint32_t flags) {
989    Mutex::Autolock autoLock(mLock);
990
991    mPlayerFlags = flags;
992}
993
994}  // namespace android
995