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