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