mediaplayer.cpp revision bea47bc22b2939b324b47fd0d70e6c7e6fbc82d2 
1/* mediaplayer.cpp
2**
3** Copyright 2006, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9**     http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18//#define LOG_NDEBUG 0
19#define LOG_TAG "MediaPlayer"
20#include <utils/Log.h>
21
22#include <sys/types.h>
23#include <sys/stat.h>
24#include <unistd.h>
25#include <fcntl.h>
26
27#include <binder/IServiceManager.h>
28#include <binder/IPCThreadState.h>
29
30#include <gui/SurfaceTextureClient.h>
31
32#include <media/mediaplayer.h>
33#include <media/AudioTrack.h>
34
35#include <surfaceflinger/Surface.h>
36
37#include <binder/MemoryBase.h>
38
39#include <utils/KeyedVector.h>
40#include <utils/String8.h>
41
42#include <system/audio.h>
43#include <system/window.h>
44
45namespace android {
46
47MediaPlayer::MediaPlayer()
48{
49    LOGV("constructor");
50    mListener = NULL;
51    mCookie = NULL;
52    mDuration = -1;
53    mStreamType = AUDIO_STREAM_MUSIC;
54    mCurrentPosition = -1;
55    mSeekPosition = -1;
56    mCurrentState = MEDIA_PLAYER_IDLE;
57    mPrepareSync = false;
58    mPrepareStatus = NO_ERROR;
59    mLoop = false;
60    mLeftVolume = mRightVolume = 1.0;
61    mVideoWidth = mVideoHeight = 0;
62    mLockThreadId = 0;
63    mAudioSessionId = AudioSystem::newAudioSessionId();
64    mSendLevel = 0;
65}
66
67MediaPlayer::~MediaPlayer()
68{
69    LOGV("destructor");
70    disconnect();
71    IPCThreadState::self()->flushCommands();
72}
73
74void MediaPlayer::disconnect()
75{
76    LOGV("disconnect");
77    sp<IMediaPlayer> p;
78    {
79        Mutex::Autolock _l(mLock);
80        p = mPlayer;
81        mPlayer.clear();
82    }
83
84    if (p != 0) {
85        p->disconnect();
86    }
87
88    disconnectNativeWindow();
89}
90
91// always call with lock held
92void MediaPlayer::clear_l()
93{
94    mDuration = -1;
95    mCurrentPosition = -1;
96    mSeekPosition = -1;
97    mVideoWidth = mVideoHeight = 0;
98}
99
100status_t MediaPlayer::setListener(const sp<MediaPlayerListener>& listener)
101{
102    LOGV("setListener");
103    Mutex::Autolock _l(mLock);
104    mListener = listener;
105    return NO_ERROR;
106}
107
108
109status_t MediaPlayer::setDataSource(const sp<IMediaPlayer>& player)
110{
111    status_t err = UNKNOWN_ERROR;
112    sp<IMediaPlayer> p;
113    { // scope for the lock
114        Mutex::Autolock _l(mLock);
115
116        if ( !( (mCurrentState & MEDIA_PLAYER_IDLE) ||
117                (mCurrentState == MEDIA_PLAYER_STATE_ERROR ) ) ) {
118            LOGE("setDataSource called in state %d", mCurrentState);
119            return INVALID_OPERATION;
120        }
121
122        clear_l();
123        p = mPlayer;
124        mPlayer = player;
125        if (player != 0) {
126            mCurrentState = MEDIA_PLAYER_INITIALIZED;
127            err = NO_ERROR;
128        } else {
129            LOGE("Unable to to create media player");
130        }
131    }
132
133    if (p != 0) {
134        p->disconnect();
135    }
136
137    return err;
138}
139
140status_t MediaPlayer::setDataSource(
141        const char *url, const KeyedVector<String8, String8> *headers)
142{
143    LOGV("setDataSource(%s)", url);
144    status_t err = BAD_VALUE;
145    if (url != NULL) {
146        const sp<IMediaPlayerService>& service(getMediaPlayerService());
147        if (service != 0) {
148            sp<IMediaPlayer> player(
149                    service->create(getpid(), this, url, headers, mAudioSessionId));
150            err = setDataSource(player);
151        }
152    }
153    return err;
154}
155
156status_t MediaPlayer::setDataSource(int fd, int64_t offset, int64_t length)
157{
158    LOGV("setDataSource(%d, %lld, %lld)", fd, offset, length);
159    status_t err = UNKNOWN_ERROR;
160    const sp<IMediaPlayerService>& service(getMediaPlayerService());
161    if (service != 0) {
162        sp<IMediaPlayer> player(service->create(getpid(), this, fd, offset, length, mAudioSessionId));
163        err = setDataSource(player);
164    }
165    return err;
166}
167
168status_t MediaPlayer::invoke(const Parcel& request, Parcel *reply)
169{
170    Mutex::Autolock _l(mLock);
171    const bool hasBeenInitialized =
172            (mCurrentState != MEDIA_PLAYER_STATE_ERROR) &&
173            ((mCurrentState & MEDIA_PLAYER_IDLE) != MEDIA_PLAYER_IDLE);
174    if ((mPlayer != NULL) && hasBeenInitialized) {
175         LOGV("invoke %d", request.dataSize());
176         return  mPlayer->invoke(request, reply);
177    }
178    LOGE("invoke failed: wrong state %X", mCurrentState);
179    return INVALID_OPERATION;
180}
181
182status_t MediaPlayer::setMetadataFilter(const Parcel& filter)
183{
184    LOGD("setMetadataFilter");
185    Mutex::Autolock lock(mLock);
186    if (mPlayer == NULL) {
187        return NO_INIT;
188    }
189    return mPlayer->setMetadataFilter(filter);
190}
191
192status_t MediaPlayer::getMetadata(bool update_only, bool apply_filter, Parcel *metadata)
193{
194    LOGD("getMetadata");
195    Mutex::Autolock lock(mLock);
196    if (mPlayer == NULL) {
197        return NO_INIT;
198    }
199    return mPlayer->getMetadata(update_only, apply_filter, metadata);
200}
201
202void MediaPlayer::disconnectNativeWindow() {
203    if (mConnectedWindow != NULL) {
204        status_t err = native_window_disconnect(mConnectedWindow.get(),
205                NATIVE_WINDOW_API_MEDIA);
206
207        if (err != OK) {
208            LOGW("native_window_disconnect returned an error: %s (%d)",
209                    strerror(-err), err);
210        }
211    }
212    mConnectedWindow.clear();
213}
214
215status_t MediaPlayer::setVideoSurface(const sp<Surface>& surface)
216{
217    LOGV("setVideoSurface");
218    Mutex::Autolock _l(mLock);
219    if (mPlayer == 0) return NO_INIT;
220
221    sp<IBinder> binder(surface == NULL ? NULL : surface->asBinder());
222    if (mConnectedWindowBinder == binder) {
223        return OK;
224    }
225
226    if (surface != NULL) {
227        status_t err = native_window_connect(surface.get(),
228                NATIVE_WINDOW_API_MEDIA);
229
230        if (err != OK) {
231            // Note that we must do the reset before disconnecting from the ANW.
232            // Otherwise queue/dequeue calls could be made on the disconnected
233            // ANW, which may result in errors.
234            reset_l();
235
236            disconnectNativeWindow();
237
238            return err;
239        }
240    }
241
242    // Note that we must set the player's new surface before disconnecting the
243    // old one.  Otherwise queue/dequeue calls could be made on the disconnected
244    // ANW, which may result in errors.
245    status_t err = mPlayer->setVideoSurface(surface);
246
247    disconnectNativeWindow();
248
249    mConnectedWindow = surface;
250
251    if (err == OK) {
252        mConnectedWindowBinder = binder;
253    } else {
254        disconnectNativeWindow();
255    }
256
257    return err;
258}
259
260status_t MediaPlayer::setVideoSurfaceTexture(
261        const sp<ISurfaceTexture>& surfaceTexture)
262{
263    LOGV("setVideoSurfaceTexture");
264    Mutex::Autolock _l(mLock);
265    if (mPlayer == 0) return NO_INIT;
266
267    sp<IBinder> binder(surfaceTexture == NULL ? NULL :
268            surfaceTexture->asBinder());
269    if (mConnectedWindowBinder == binder) {
270        return OK;
271    }
272
273    sp<ANativeWindow> anw;
274    if (surfaceTexture != NULL) {
275        anw = new SurfaceTextureClient(surfaceTexture);
276        status_t err = native_window_connect(anw.get(),
277                NATIVE_WINDOW_API_MEDIA);
278
279        if (err != OK) {
280            // Note that we must do the reset before disconnecting from the ANW.
281            // Otherwise queue/dequeue calls could be made on the disconnected
282            // ANW, which may result in errors.
283            reset_l();
284
285            disconnectNativeWindow();
286
287            return err;
288        }
289    }
290
291    // Note that we must set the player's new SurfaceTexture before
292    // disconnecting the old one.  Otherwise queue/dequeue calls could be made
293    // on the disconnected ANW, which may result in errors.
294    status_t err = mPlayer->setVideoSurfaceTexture(surfaceTexture);
295
296    disconnectNativeWindow();
297
298    mConnectedWindow = anw;
299
300    if (err == OK) {
301        mConnectedWindowBinder = binder;
302    } else {
303        disconnectNativeWindow();
304    }
305
306    return err;
307}
308
309// must call with lock held
310status_t MediaPlayer::prepareAsync_l()
311{
312    if ( (mPlayer != 0) && ( mCurrentState & ( MEDIA_PLAYER_INITIALIZED | MEDIA_PLAYER_STOPPED) ) ) {
313        mPlayer->setAudioStreamType(mStreamType);
314        mCurrentState = MEDIA_PLAYER_PREPARING;
315        return mPlayer->prepareAsync();
316    }
317    LOGE("prepareAsync called in state %d", mCurrentState);
318    return INVALID_OPERATION;
319}
320
321// TODO: In case of error, prepareAsync provides the caller with 2 error codes,
322// one defined in the Android framework and one provided by the implementation
323// that generated the error. The sync version of prepare returns only 1 error
324// code.
325status_t MediaPlayer::prepare()
326{
327    LOGV("prepare");
328    Mutex::Autolock _l(mLock);
329    mLockThreadId = getThreadId();
330    if (mPrepareSync) {
331        mLockThreadId = 0;
332        return -EALREADY;
333    }
334    mPrepareSync = true;
335    status_t ret = prepareAsync_l();
336    if (ret != NO_ERROR) {
337        mLockThreadId = 0;
338        return ret;
339    }
340
341    if (mPrepareSync) {
342        mSignal.wait(mLock);  // wait for prepare done
343        mPrepareSync = false;
344    }
345    LOGV("prepare complete - status=%d", mPrepareStatus);
346    mLockThreadId = 0;
347    return mPrepareStatus;
348}
349
350status_t MediaPlayer::prepareAsync()
351{
352    LOGV("prepareAsync");
353    Mutex::Autolock _l(mLock);
354    return prepareAsync_l();
355}
356
357status_t MediaPlayer::start()
358{
359    LOGV("start");
360    Mutex::Autolock _l(mLock);
361    if (mCurrentState & MEDIA_PLAYER_STARTED)
362        return NO_ERROR;
363    if ( (mPlayer != 0) && ( mCurrentState & ( MEDIA_PLAYER_PREPARED |
364                    MEDIA_PLAYER_PLAYBACK_COMPLETE | MEDIA_PLAYER_PAUSED ) ) ) {
365        mPlayer->setLooping(mLoop);
366        mPlayer->setVolume(mLeftVolume, mRightVolume);
367        mPlayer->setAuxEffectSendLevel(mSendLevel);
368        mCurrentState = MEDIA_PLAYER_STARTED;
369        status_t ret = mPlayer->start();
370        if (ret != NO_ERROR) {
371            mCurrentState = MEDIA_PLAYER_STATE_ERROR;
372        } else {
373            if (mCurrentState == MEDIA_PLAYER_PLAYBACK_COMPLETE) {
374                LOGV("playback completed immediately following start()");
375            }
376        }
377        return ret;
378    }
379    LOGE("start called in state %d", mCurrentState);
380    return INVALID_OPERATION;
381}
382
383status_t MediaPlayer::stop()
384{
385    LOGV("stop");
386    Mutex::Autolock _l(mLock);
387    if (mCurrentState & MEDIA_PLAYER_STOPPED) return NO_ERROR;
388    if ( (mPlayer != 0) && ( mCurrentState & ( MEDIA_PLAYER_STARTED | MEDIA_PLAYER_PREPARED |
389                    MEDIA_PLAYER_PAUSED | MEDIA_PLAYER_PLAYBACK_COMPLETE ) ) ) {
390        status_t ret = mPlayer->stop();
391        if (ret != NO_ERROR) {
392            mCurrentState = MEDIA_PLAYER_STATE_ERROR;
393        } else {
394            mCurrentState = MEDIA_PLAYER_STOPPED;
395        }
396        return ret;
397    }
398    LOGE("stop called in state %d", mCurrentState);
399    return INVALID_OPERATION;
400}
401
402status_t MediaPlayer::pause()
403{
404    LOGV("pause");
405    Mutex::Autolock _l(mLock);
406    if (mCurrentState & (MEDIA_PLAYER_PAUSED|MEDIA_PLAYER_PLAYBACK_COMPLETE))
407        return NO_ERROR;
408    if ((mPlayer != 0) && (mCurrentState & MEDIA_PLAYER_STARTED)) {
409        status_t ret = mPlayer->pause();
410        if (ret != NO_ERROR) {
411            mCurrentState = MEDIA_PLAYER_STATE_ERROR;
412        } else {
413            mCurrentState = MEDIA_PLAYER_PAUSED;
414        }
415        return ret;
416    }
417    LOGE("pause called in state %d", mCurrentState);
418    return INVALID_OPERATION;
419}
420
421bool MediaPlayer::isPlaying()
422{
423    Mutex::Autolock _l(mLock);
424    if (mPlayer != 0) {
425        bool temp = false;
426        mPlayer->isPlaying(&temp);
427        LOGV("isPlaying: %d", temp);
428        if ((mCurrentState & MEDIA_PLAYER_STARTED) && ! temp) {
429            LOGE("internal/external state mismatch corrected");
430            mCurrentState = MEDIA_PLAYER_PAUSED;
431        }
432        return temp;
433    }
434    LOGV("isPlaying: no active player");
435    return false;
436}
437
438status_t MediaPlayer::getVideoWidth(int *w)
439{
440    LOGV("getVideoWidth");
441    Mutex::Autolock _l(mLock);
442    if (mPlayer == 0) return INVALID_OPERATION;
443    *w = mVideoWidth;
444    return NO_ERROR;
445}
446
447status_t MediaPlayer::getVideoHeight(int *h)
448{
449    LOGV("getVideoHeight");
450    Mutex::Autolock _l(mLock);
451    if (mPlayer == 0) return INVALID_OPERATION;
452    *h = mVideoHeight;
453    return NO_ERROR;
454}
455
456status_t MediaPlayer::getCurrentPosition(int *msec)
457{
458    LOGV("getCurrentPosition");
459    Mutex::Autolock _l(mLock);
460    if (mPlayer != 0) {
461        if (mCurrentPosition >= 0) {
462            LOGV("Using cached seek position: %d", mCurrentPosition);
463            *msec = mCurrentPosition;
464            return NO_ERROR;
465        }
466        return mPlayer->getCurrentPosition(msec);
467    }
468    return INVALID_OPERATION;
469}
470
471status_t MediaPlayer::getDuration_l(int *msec)
472{
473    LOGV("getDuration");
474    bool isValidState = (mCurrentState & (MEDIA_PLAYER_PREPARED | MEDIA_PLAYER_STARTED | MEDIA_PLAYER_PAUSED | MEDIA_PLAYER_STOPPED | MEDIA_PLAYER_PLAYBACK_COMPLETE));
475    if (mPlayer != 0 && isValidState) {
476        status_t ret = NO_ERROR;
477        if (mDuration <= 0)
478            ret = mPlayer->getDuration(&mDuration);
479        if (msec)
480            *msec = mDuration;
481        return ret;
482    }
483    LOGE("Attempt to call getDuration without a valid mediaplayer");
484    return INVALID_OPERATION;
485}
486
487status_t MediaPlayer::getDuration(int *msec)
488{
489    Mutex::Autolock _l(mLock);
490    return getDuration_l(msec);
491}
492
493status_t MediaPlayer::seekTo_l(int msec)
494{
495    LOGV("seekTo %d", msec);
496    if ((mPlayer != 0) && ( mCurrentState & ( MEDIA_PLAYER_STARTED | MEDIA_PLAYER_PREPARED | MEDIA_PLAYER_PAUSED |  MEDIA_PLAYER_PLAYBACK_COMPLETE) ) ) {
497        if ( msec < 0 ) {
498            LOGW("Attempt to seek to invalid position: %d", msec);
499            msec = 0;
500        } else if ((mDuration > 0) && (msec > mDuration)) {
501            LOGW("Attempt to seek to past end of file: request = %d, EOF = %d", msec, mDuration);
502            msec = mDuration;
503        }
504        // cache duration
505        mCurrentPosition = msec;
506        if (mSeekPosition < 0) {
507            getDuration_l(NULL);
508            mSeekPosition = msec;
509            return mPlayer->seekTo(msec);
510        }
511        else {
512            LOGV("Seek in progress - queue up seekTo[%d]", msec);
513            return NO_ERROR;
514        }
515    }
516    LOGE("Attempt to perform seekTo in wrong state: mPlayer=%p, mCurrentState=%u", mPlayer.get(), mCurrentState);
517    return INVALID_OPERATION;
518}
519
520status_t MediaPlayer::seekTo(int msec)
521{
522    mLockThreadId = getThreadId();
523    Mutex::Autolock _l(mLock);
524    status_t result = seekTo_l(msec);
525    mLockThreadId = 0;
526
527    return result;
528}
529
530status_t MediaPlayer::reset_l()
531{
532    mLoop = false;
533    if (mCurrentState == MEDIA_PLAYER_IDLE) return NO_ERROR;
534    mPrepareSync = false;
535    if (mPlayer != 0) {
536        status_t ret = mPlayer->reset();
537        if (ret != NO_ERROR) {
538            LOGE("reset() failed with return code (%d)", ret);
539            mCurrentState = MEDIA_PLAYER_STATE_ERROR;
540        } else {
541            mCurrentState = MEDIA_PLAYER_IDLE;
542        }
543        // setDataSource has to be called again to create a
544        // new mediaplayer.
545        mPlayer = 0;
546        return ret;
547    }
548    clear_l();
549    return NO_ERROR;
550}
551
552status_t MediaPlayer::reset()
553{
554    LOGV("reset");
555    Mutex::Autolock _l(mLock);
556    return reset_l();
557}
558
559status_t MediaPlayer::setAudioStreamType(int type)
560{
561    LOGV("MediaPlayer::setAudioStreamType");
562    Mutex::Autolock _l(mLock);
563    if (mStreamType == type) return NO_ERROR;
564    if (mCurrentState & ( MEDIA_PLAYER_PREPARED | MEDIA_PLAYER_STARTED |
565                MEDIA_PLAYER_PAUSED | MEDIA_PLAYER_PLAYBACK_COMPLETE ) ) {
566        // Can't change the stream type after prepare
567        LOGE("setAudioStream called in state %d", mCurrentState);
568        return INVALID_OPERATION;
569    }
570    // cache
571    mStreamType = type;
572    return OK;
573}
574
575status_t MediaPlayer::setLooping(int loop)
576{
577    LOGV("MediaPlayer::setLooping");
578    Mutex::Autolock _l(mLock);
579    mLoop = (loop != 0);
580    if (mPlayer != 0) {
581        return mPlayer->setLooping(loop);
582    }
583    return OK;
584}
585
586bool MediaPlayer::isLooping() {
587    LOGV("isLooping");
588    Mutex::Autolock _l(mLock);
589    if (mPlayer != 0) {
590        return mLoop;
591    }
592    LOGV("isLooping: no active player");
593    return false;
594}
595
596status_t MediaPlayer::setVolume(float leftVolume, float rightVolume)
597{
598    LOGV("MediaPlayer::setVolume(%f, %f)", leftVolume, rightVolume);
599    Mutex::Autolock _l(mLock);
600    mLeftVolume = leftVolume;
601    mRightVolume = rightVolume;
602    if (mPlayer != 0) {
603        return mPlayer->setVolume(leftVolume, rightVolume);
604    }
605    return OK;
606}
607
608status_t MediaPlayer::setAudioSessionId(int sessionId)
609{
610    LOGV("MediaPlayer::setAudioSessionId(%d)", sessionId);
611    Mutex::Autolock _l(mLock);
612    if (!(mCurrentState & MEDIA_PLAYER_IDLE)) {
613        LOGE("setAudioSessionId called in state %d", mCurrentState);
614        return INVALID_OPERATION;
615    }
616    if (sessionId < 0) {
617        return BAD_VALUE;
618    }
619    mAudioSessionId = sessionId;
620    return NO_ERROR;
621}
622
623int MediaPlayer::getAudioSessionId()
624{
625    Mutex::Autolock _l(mLock);
626    return mAudioSessionId;
627}
628
629status_t MediaPlayer::setAuxEffectSendLevel(float level)
630{
631    LOGV("MediaPlayer::setAuxEffectSendLevel(%f)", level);
632    Mutex::Autolock _l(mLock);
633    mSendLevel = level;
634    if (mPlayer != 0) {
635        return mPlayer->setAuxEffectSendLevel(level);
636    }
637    return OK;
638}
639
640status_t MediaPlayer::attachAuxEffect(int effectId)
641{
642    LOGV("MediaPlayer::attachAuxEffect(%d)", effectId);
643    Mutex::Autolock _l(mLock);
644    if (mPlayer == 0 ||
645        (mCurrentState & MEDIA_PLAYER_IDLE) ||
646        (mCurrentState == MEDIA_PLAYER_STATE_ERROR )) {
647        LOGE("attachAuxEffect called in state %d", mCurrentState);
648        return INVALID_OPERATION;
649    }
650
651    return mPlayer->attachAuxEffect(effectId);
652}
653
654status_t MediaPlayer::setParameter(int key, const Parcel& request)
655{
656    LOGV("MediaPlayer::setParameter(%d)", key);
657    Mutex::Autolock _l(mLock);
658    if (mPlayer != NULL) {
659        return  mPlayer->setParameter(key, request);
660    }
661    LOGV("setParameter: no active player");
662    return INVALID_OPERATION;
663}
664
665status_t MediaPlayer::getParameter(int key, Parcel *reply)
666{
667    LOGV("MediaPlayer::getParameter(%d)", key);
668    Mutex::Autolock _l(mLock);
669    if (mPlayer != NULL) {
670         return  mPlayer->getParameter(key, reply);
671    }
672    LOGV("getParameter: no active player");
673    return INVALID_OPERATION;
674}
675
676void MediaPlayer::notify(int msg, int ext1, int ext2, const Parcel *obj)
677{
678    LOGV("message received msg=%d, ext1=%d, ext2=%d", msg, ext1, ext2);
679    bool send = true;
680    bool locked = false;
681
682    // TODO: In the future, we might be on the same thread if the app is
683    // running in the same process as the media server. In that case,
684    // this will deadlock.
685    //
686    // The threadId hack below works around this for the care of prepare
687    // and seekTo within the same process.
688    // FIXME: Remember, this is a hack, it's not even a hack that is applied
689    // consistently for all use-cases, this needs to be revisited.
690     if (mLockThreadId != getThreadId()) {
691        mLock.lock();
692        locked = true;
693    }
694
695    // Allows calls from JNI in idle state to notify errors
696    if (!(msg == MEDIA_ERROR && mCurrentState == MEDIA_PLAYER_IDLE) && mPlayer == 0) {
697        LOGV("notify(%d, %d, %d) callback on disconnected mediaplayer", msg, ext1, ext2);
698        if (locked) mLock.unlock();   // release the lock when done.
699        return;
700    }
701
702    switch (msg) {
703    case MEDIA_NOP: // interface test message
704        break;
705    case MEDIA_PREPARED:
706        LOGV("prepared");
707        mCurrentState = MEDIA_PLAYER_PREPARED;
708        if (mPrepareSync) {
709            LOGV("signal application thread");
710            mPrepareSync = false;
711            mPrepareStatus = NO_ERROR;
712            mSignal.signal();
713        }
714        break;
715    case MEDIA_PLAYBACK_COMPLETE:
716        LOGV("playback complete");
717        if (mCurrentState == MEDIA_PLAYER_IDLE) {
718            LOGE("playback complete in idle state");
719        }
720        if (!mLoop) {
721            mCurrentState = MEDIA_PLAYER_PLAYBACK_COMPLETE;
722        }
723        break;
724    case MEDIA_ERROR:
725        // Always log errors.
726        // ext1: Media framework error code.
727        // ext2: Implementation dependant error code.
728        LOGE("error (%d, %d)", ext1, ext2);
729        mCurrentState = MEDIA_PLAYER_STATE_ERROR;
730        if (mPrepareSync)
731        {
732            LOGV("signal application thread");
733            mPrepareSync = false;
734            mPrepareStatus = ext1;
735            mSignal.signal();
736            send = false;
737        }
738        break;
739    case MEDIA_INFO:
740        // ext1: Media framework error code.
741        // ext2: Implementation dependant error code.
742        if (ext1 != MEDIA_INFO_VIDEO_TRACK_LAGGING) {
743            LOGW("info/warning (%d, %d)", ext1, ext2);
744        }
745        break;
746    case MEDIA_SEEK_COMPLETE:
747        LOGV("Received seek complete");
748        if (mSeekPosition != mCurrentPosition) {
749            LOGV("Executing queued seekTo(%d)", mSeekPosition);
750            mSeekPosition = -1;
751            seekTo_l(mCurrentPosition);
752        }
753        else {
754            LOGV("All seeks complete - return to regularly scheduled program");
755            mCurrentPosition = mSeekPosition = -1;
756        }
757        break;
758    case MEDIA_BUFFERING_UPDATE:
759        LOGV("buffering %d", ext1);
760        break;
761    case MEDIA_SET_VIDEO_SIZE:
762        LOGV("New video size %d x %d", ext1, ext2);
763        mVideoWidth = ext1;
764        mVideoHeight = ext2;
765        break;
766    case MEDIA_TIMED_TEXT:
767        LOGV("Received timed text message");
768        break;
769    default:
770        LOGV("unrecognized message: (%d, %d, %d)", msg, ext1, ext2);
771        break;
772    }
773
774    sp<MediaPlayerListener> listener = mListener;
775    if (locked) mLock.unlock();
776
777    // this prevents re-entrant calls into client code
778    if ((listener != 0) && send) {
779        Mutex::Autolock _l(mNotifyLock);
780        LOGV("callback application");
781        listener->notify(msg, ext1, ext2, obj);
782        LOGV("back from callback");
783    }
784}
785
786/*static*/ sp<IMemory> MediaPlayer::decode(const char* url, uint32_t *pSampleRate, int* pNumChannels, int* pFormat)
787{
788    LOGV("decode(%s)", url);
789    sp<IMemory> p;
790    const sp<IMediaPlayerService>& service = getMediaPlayerService();
791    if (service != 0) {
792        p = service->decode(url, pSampleRate, pNumChannels, pFormat);
793    } else {
794        LOGE("Unable to locate media service");
795    }
796    return p;
797
798}
799
800void MediaPlayer::died()
801{
802    LOGV("died");
803    notify(MEDIA_ERROR, MEDIA_ERROR_SERVER_DIED, 0);
804}
805
806/*static*/ sp<IMemory> MediaPlayer::decode(int fd, int64_t offset, int64_t length, uint32_t *pSampleRate, int* pNumChannels, int* pFormat)
807{
808    LOGV("decode(%d, %lld, %lld)", fd, offset, length);
809    sp<IMemory> p;
810    const sp<IMediaPlayerService>& service = getMediaPlayerService();
811    if (service != 0) {
812        p = service->decode(fd, offset, length, pSampleRate, pNumChannels, pFormat);
813    } else {
814        LOGE("Unable to locate media service");
815    }
816    return p;
817
818}
819
820}; // namespace android
821