mediaplayer.h revision 1173118eace0e9e347cb007f0da817cee87579ed 
1/*
2 * Copyright (C) 2007 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#ifndef ANDROID_MEDIAPLAYER_H
18#define ANDROID_MEDIAPLAYER_H
19
20#include <binder/IMemory.h>
21#include <media/IMediaPlayerClient.h>
22#include <media/IMediaPlayer.h>
23#include <media/IMediaDeathNotifier.h>
24
25#include <utils/KeyedVector.h>
26#include <utils/String8.h>
27
28namespace android {
29
30class Surface;
31class ISurfaceTexture;
32
33enum media_event_type {
34    MEDIA_NOP               = 0, // interface test message
35    MEDIA_PREPARED          = 1,
36    MEDIA_PLAYBACK_COMPLETE = 2,
37    MEDIA_BUFFERING_UPDATE  = 3,
38    MEDIA_SEEK_COMPLETE     = 4,
39    MEDIA_SET_VIDEO_SIZE    = 5,
40    MEDIA_ERROR             = 100,
41    MEDIA_INFO              = 200,
42};
43
44// Generic error codes for the media player framework.  Errors are fatal, the
45// playback must abort.
46//
47// Errors are communicated back to the client using the
48// MediaPlayerListener::notify method defined below.
49// In this situation, 'notify' is invoked with the following:
50//   'msg' is set to MEDIA_ERROR.
51//   'ext1' should be a value from the enum media_error_type.
52//   'ext2' contains an implementation dependant error code to provide
53//          more details. Should default to 0 when not used.
54//
55// The codes are distributed as follow:
56//   0xx: Reserved
57//   1xx: Android Player errors. Something went wrong inside the MediaPlayer.
58//   2xx: Media errors (e.g Codec not supported). There is a problem with the
59//        media itself.
60//   3xx: Runtime errors. Some extraordinary condition arose making the playback
61//        impossible.
62//
63enum media_error_type {
64    // 0xx
65    MEDIA_ERROR_UNKNOWN = 1,
66    // 1xx
67    MEDIA_ERROR_SERVER_DIED = 100,
68    // 2xx
69    MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK = 200,
70    // 3xx
71};
72
73
74// Info and warning codes for the media player framework.  These are non fatal,
75// the playback is going on but there might be some user visible issues.
76//
77// Info and warning messages are communicated back to the client using the
78// MediaPlayerListener::notify method defined below.  In this situation,
79// 'notify' is invoked with the following:
80//   'msg' is set to MEDIA_INFO.
81//   'ext1' should be a value from the enum media_info_type.
82//   'ext2' contains an implementation dependant info code to provide
83//          more details. Should default to 0 when not used.
84//
85// The codes are distributed as follow:
86//   0xx: Reserved
87//   7xx: Android Player info/warning (e.g player lagging behind.)
88//   8xx: Media info/warning (e.g media badly interleaved.)
89//
90enum media_info_type {
91    // 0xx
92    MEDIA_INFO_UNKNOWN = 1,
93    // 7xx
94    // The video is too complex for the decoder: it can't decode frames fast
95    // enough. Possibly only the audio plays fine at this stage.
96    MEDIA_INFO_VIDEO_TRACK_LAGGING = 700,
97    // MediaPlayer is temporarily pausing playback internally in order to
98    // buffer more data.
99    MEDIA_INFO_BUFFERING_START = 701,
100    // MediaPlayer is resuming playback after filling buffers.
101    MEDIA_INFO_BUFFERING_END = 702,
102    // 8xx
103    // Bad interleaving means that a media has been improperly interleaved or not
104    // interleaved at all, e.g has all the video samples first then all the audio
105    // ones. Video is playing but a lot of disk seek may be happening.
106    MEDIA_INFO_BAD_INTERLEAVING = 800,
107    // The media is not seekable (e.g live stream).
108    MEDIA_INFO_NOT_SEEKABLE = 801,
109    // New media metadata is available.
110    MEDIA_INFO_METADATA_UPDATE = 802,
111};
112
113
114
115enum media_player_states {
116    MEDIA_PLAYER_STATE_ERROR        = 0,
117    MEDIA_PLAYER_IDLE               = 1 << 0,
118    MEDIA_PLAYER_INITIALIZED        = 1 << 1,
119    MEDIA_PLAYER_PREPARING          = 1 << 2,
120    MEDIA_PLAYER_PREPARED           = 1 << 3,
121    MEDIA_PLAYER_STARTED            = 1 << 4,
122    MEDIA_PLAYER_PAUSED             = 1 << 5,
123    MEDIA_PLAYER_STOPPED            = 1 << 6,
124    MEDIA_PLAYER_PLAYBACK_COMPLETE  = 1 << 7
125};
126
127// ----------------------------------------------------------------------------
128// ref-counted object for callbacks
129class MediaPlayerListener: virtual public RefBase
130{
131public:
132    virtual void notify(int msg, int ext1, int ext2) = 0;
133};
134
135class MediaPlayer : public BnMediaPlayerClient,
136                    public virtual IMediaDeathNotifier
137{
138public:
139    MediaPlayer();
140    ~MediaPlayer();
141            void            died();
142            void            disconnect();
143
144            status_t        setDataSource(
145                    const char *url,
146                    const KeyedVector<String8, String8> *headers);
147
148            status_t        setDataSource(int fd, int64_t offset, int64_t length);
149            status_t        setVideoSurface(const sp<Surface>& surface);
150            status_t        setVideoSurfaceTexture(
151                                    const sp<ISurfaceTexture>& surfaceTexture);
152            status_t        setListener(const sp<MediaPlayerListener>& listener);
153            status_t        prepare();
154            status_t        prepareAsync();
155            status_t        start();
156            status_t        stop();
157            status_t        pause();
158            bool            isPlaying();
159            status_t        getVideoWidth(int *w);
160            status_t        getVideoHeight(int *h);
161            status_t        seekTo(int msec);
162            status_t        getCurrentPosition(int *msec);
163            status_t        getDuration(int *msec);
164            status_t        reset();
165            status_t        setAudioStreamType(int type);
166            status_t        setLooping(int loop);
167            bool            isLooping();
168            status_t        setVolume(float leftVolume, float rightVolume);
169            void            notify(int msg, int ext1, int ext2);
170    static  sp<IMemory>     decode(const char* url, uint32_t *pSampleRate, int* pNumChannels, int* pFormat);
171    static  sp<IMemory>     decode(int fd, int64_t offset, int64_t length, uint32_t *pSampleRate, int* pNumChannels, int* pFormat);
172            status_t        invoke(const Parcel& request, Parcel *reply);
173            status_t        setMetadataFilter(const Parcel& filter);
174            status_t        getMetadata(bool update_only, bool apply_filter, Parcel *metadata);
175            status_t        setAudioSessionId(int sessionId);
176            int             getAudioSessionId();
177            status_t        setAuxEffectSendLevel(float level);
178            status_t        attachAuxEffect(int effectId);
179private:
180            void            clear_l();
181            status_t        seekTo_l(int msec);
182            status_t        prepareAsync_l();
183            status_t        getDuration_l(int *msec);
184            status_t        setDataSource(const sp<IMediaPlayer>& player);
185
186    sp<IMediaPlayer>            mPlayer;
187    thread_id_t                 mLockThreadId;
188    Mutex                       mLock;
189    Mutex                       mNotifyLock;
190    Condition                   mSignal;
191    sp<MediaPlayerListener>     mListener;
192    void*                       mCookie;
193    media_player_states         mCurrentState;
194    int                         mDuration;
195    int                         mCurrentPosition;
196    int                         mSeekPosition;
197    bool                        mPrepareSync;
198    status_t                    mPrepareStatus;
199    int                         mStreamType;
200    bool                        mLoop;
201    float                       mLeftVolume;
202    float                       mRightVolume;
203    int                         mVideoWidth;
204    int                         mVideoHeight;
205    int                         mAudioSessionId;
206    float                       mSendLevel;
207};
208
209}; // namespace android
210
211#endif // ANDROID_MEDIAPLAYER_H
212