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 <arpa/inet.h> 21 22 #include <binder/IMemory.h> 23 #include <media/IMediaPlayerClient.h> 24 #include <media/IMediaPlayer.h> 25 #include <media/IMediaDeathNotifier.h> 26 #include <media/IStreamSource.h> 27 28 #include <utils/KeyedVector.h> 29 #include <utils/String8.h> 30 31 class ANativeWindow; 32 33 namespace android { 34 35 class Surface; 36 class IGraphicBufferProducer; 37 38 enum media_event_type { 39 MEDIA_NOP = 0, // interface test message 40 MEDIA_PREPARED = 1, 41 MEDIA_PLAYBACK_COMPLETE = 2, 42 MEDIA_BUFFERING_UPDATE = 3, 43 MEDIA_SEEK_COMPLETE = 4, 44 MEDIA_SET_VIDEO_SIZE = 5, 45 MEDIA_STARTED = 6, 46 MEDIA_PAUSED = 7, 47 MEDIA_STOPPED = 8, 48 MEDIA_SKIPPED = 9, 49 MEDIA_TIMED_TEXT = 99, 50 MEDIA_ERROR = 100, 51 MEDIA_INFO = 200, 52 MEDIA_SUBTITLE_DATA = 201, 53 }; 54 55 // Generic error codes for the media player framework. Errors are fatal, the 56 // playback must abort. 57 // 58 // Errors are communicated back to the client using the 59 // MediaPlayerListener::notify method defined below. 60 // In this situation, 'notify' is invoked with the following: 61 // 'msg' is set to MEDIA_ERROR. 62 // 'ext1' should be a value from the enum media_error_type. 63 // 'ext2' contains an implementation dependant error code to provide 64 // more details. Should default to 0 when not used. 65 // 66 // The codes are distributed as follow: 67 // 0xx: Reserved 68 // 1xx: Android Player errors. Something went wrong inside the MediaPlayer. 69 // 2xx: Media errors (e.g Codec not supported). There is a problem with the 70 // media itself. 71 // 3xx: Runtime errors. Some extraordinary condition arose making the playback 72 // impossible. 73 // 74 enum media_error_type { 75 // 0xx 76 MEDIA_ERROR_UNKNOWN = 1, 77 // 1xx 78 MEDIA_ERROR_SERVER_DIED = 100, 79 // 2xx 80 MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK = 200, 81 // 3xx 82 }; 83 84 85 // Info and warning codes for the media player framework. These are non fatal, 86 // the playback is going on but there might be some user visible issues. 87 // 88 // Info and warning messages are communicated back to the client using the 89 // MediaPlayerListener::notify method defined below. In this situation, 90 // 'notify' is invoked with the following: 91 // 'msg' is set to MEDIA_INFO. 92 // 'ext1' should be a value from the enum media_info_type. 93 // 'ext2' contains an implementation dependant info code to provide 94 // more details. Should default to 0 when not used. 95 // 96 // The codes are distributed as follow: 97 // 0xx: Reserved 98 // 7xx: Android Player info/warning (e.g player lagging behind.) 99 // 8xx: Media info/warning (e.g media badly interleaved.) 100 // 101 enum media_info_type { 102 // 0xx 103 MEDIA_INFO_UNKNOWN = 1, 104 // The player was started because it was used as the next player for another 105 // player, which just completed playback 106 MEDIA_INFO_STARTED_AS_NEXT = 2, 107 // The player just pushed the very first video frame for rendering 108 MEDIA_INFO_RENDERING_START = 3, 109 // 7xx 110 // The video is too complex for the decoder: it can't decode frames fast 111 // enough. Possibly only the audio plays fine at this stage. 112 MEDIA_INFO_VIDEO_TRACK_LAGGING = 700, 113 // MediaPlayer is temporarily pausing playback internally in order to 114 // buffer more data. 115 MEDIA_INFO_BUFFERING_START = 701, 116 // MediaPlayer is resuming playback after filling buffers. 117 MEDIA_INFO_BUFFERING_END = 702, 118 // Bandwidth in recent past 119 MEDIA_INFO_NETWORK_BANDWIDTH = 703, 120 121 // 8xx 122 // Bad interleaving means that a media has been improperly interleaved or not 123 // interleaved at all, e.g has all the video samples first then all the audio 124 // ones. Video is playing but a lot of disk seek may be happening. 125 MEDIA_INFO_BAD_INTERLEAVING = 800, 126 // The media is not seekable (e.g live stream). 127 MEDIA_INFO_NOT_SEEKABLE = 801, 128 // New media metadata is available. 129 MEDIA_INFO_METADATA_UPDATE = 802, 130 131 //9xx 132 MEDIA_INFO_TIMED_TEXT_ERROR = 900, 133 }; 134 135 136 137 enum media_player_states { 138 MEDIA_PLAYER_STATE_ERROR = 0, 139 MEDIA_PLAYER_IDLE = 1 << 0, 140 MEDIA_PLAYER_INITIALIZED = 1 << 1, 141 MEDIA_PLAYER_PREPARING = 1 << 2, 142 MEDIA_PLAYER_PREPARED = 1 << 3, 143 MEDIA_PLAYER_STARTED = 1 << 4, 144 MEDIA_PLAYER_PAUSED = 1 << 5, 145 MEDIA_PLAYER_STOPPED = 1 << 6, 146 MEDIA_PLAYER_PLAYBACK_COMPLETE = 1 << 7 147 }; 148 149 // Keep KEY_PARAMETER_* in sync with MediaPlayer.java. 150 // The same enum space is used for both set and get, in case there are future keys that 151 // can be both set and get. But as of now, all parameters are either set only or get only. 152 enum media_parameter_keys { 153 // Streaming/buffering parameters 154 KEY_PARAMETER_CACHE_STAT_COLLECT_FREQ_MS = 1100, // set only 155 156 // Return a Parcel containing a single int, which is the channel count of the 157 // audio track, or zero for error (e.g. no audio track) or unknown. 158 KEY_PARAMETER_AUDIO_CHANNEL_COUNT = 1200, // get only 159 160 // Playback rate expressed in permille (1000 is normal speed), saved as int32_t, with negative 161 // values used for rewinding or reverse playback. 162 KEY_PARAMETER_PLAYBACK_RATE_PERMILLE = 1300, // set only 163 }; 164 165 // Keep INVOKE_ID_* in sync with MediaPlayer.java. 166 enum media_player_invoke_ids { 167 INVOKE_ID_GET_TRACK_INFO = 1, 168 INVOKE_ID_ADD_EXTERNAL_SOURCE = 2, 169 INVOKE_ID_ADD_EXTERNAL_SOURCE_FD = 3, 170 INVOKE_ID_SELECT_TRACK = 4, 171 INVOKE_ID_UNSELECT_TRACK = 5, 172 INVOKE_ID_SET_VIDEO_SCALING_MODE = 6, 173 }; 174 175 // Keep MEDIA_TRACK_TYPE_* in sync with MediaPlayer.java. 176 enum media_track_type { 177 MEDIA_TRACK_TYPE_UNKNOWN = 0, 178 MEDIA_TRACK_TYPE_VIDEO = 1, 179 MEDIA_TRACK_TYPE_AUDIO = 2, 180 MEDIA_TRACK_TYPE_TIMEDTEXT = 3, 181 MEDIA_TRACK_TYPE_SUBTITLE = 4, 182 }; 183 184 // ---------------------------------------------------------------------------- 185 // ref-counted object for callbacks 186 class MediaPlayerListener: virtual public RefBase 187 { 188 public: 189 virtual void notify(int msg, int ext1, int ext2, const Parcel *obj) = 0; 190 }; 191 192 class MediaPlayer : public BnMediaPlayerClient, 193 public virtual IMediaDeathNotifier 194 { 195 public: 196 MediaPlayer(); 197 ~MediaPlayer(); 198 void died(); 199 void disconnect(); 200 201 status_t setDataSource( 202 const char *url, 203 const KeyedVector<String8, String8> *headers); 204 205 status_t setDataSource(int fd, int64_t offset, int64_t length); 206 status_t setDataSource(const sp<IStreamSource> &source); 207 status_t setVideoSurfaceTexture( 208 const sp<IGraphicBufferProducer>& bufferProducer); 209 status_t setListener(const sp<MediaPlayerListener>& listener); 210 status_t prepare(); 211 status_t prepareAsync(); 212 status_t start(); 213 status_t stop(); 214 status_t pause(); 215 bool isPlaying(); 216 status_t getVideoWidth(int *w); 217 status_t getVideoHeight(int *h); 218 status_t seekTo(int msec); 219 status_t getCurrentPosition(int *msec); 220 status_t getDuration(int *msec); 221 status_t reset(); 222 status_t setAudioStreamType(audio_stream_type_t type); 223 status_t setLooping(int loop); 224 bool isLooping(); 225 status_t setVolume(float leftVolume, float rightVolume); 226 void notify(int msg, int ext1, int ext2, const Parcel *obj = NULL); 227 static status_t decode(const char* url, uint32_t *pSampleRate, int* pNumChannels, 228 audio_format_t* pFormat, 229 const sp<IMemoryHeap>& heap, size_t *pSize); 230 static status_t decode(int fd, int64_t offset, int64_t length, uint32_t *pSampleRate, 231 int* pNumChannels, audio_format_t* pFormat, 232 const sp<IMemoryHeap>& heap, size_t *pSize); 233 status_t invoke(const Parcel& request, Parcel *reply); 234 status_t setMetadataFilter(const Parcel& filter); 235 status_t getMetadata(bool update_only, bool apply_filter, Parcel *metadata); 236 status_t setAudioSessionId(int sessionId); 237 int getAudioSessionId(); 238 status_t setAuxEffectSendLevel(float level); 239 status_t attachAuxEffect(int effectId); 240 status_t setParameter(int key, const Parcel& request); 241 status_t getParameter(int key, Parcel* reply); 242 status_t setRetransmitEndpoint(const char* addrString, uint16_t port); 243 status_t setNextMediaPlayer(const sp<MediaPlayer>& player); 244 245 status_t updateProxyConfig( 246 const char *host, int32_t port, const char *exclusionList); 247 248 private: 249 void clear_l(); 250 status_t seekTo_l(int msec); 251 status_t prepareAsync_l(); 252 status_t getDuration_l(int *msec); 253 status_t attachNewPlayer(const sp<IMediaPlayer>& player); 254 status_t reset_l(); 255 status_t doSetRetransmitEndpoint(const sp<IMediaPlayer>& player); 256 257 sp<IMediaPlayer> mPlayer; 258 thread_id_t mLockThreadId; 259 Mutex mLock; 260 Mutex mNotifyLock; 261 Condition mSignal; 262 sp<MediaPlayerListener> mListener; 263 void* mCookie; 264 media_player_states mCurrentState; 265 int mCurrentPosition; 266 int mSeekPosition; 267 bool mPrepareSync; 268 status_t mPrepareStatus; 269 audio_stream_type_t mStreamType; 270 bool mLoop; 271 float mLeftVolume; 272 float mRightVolume; 273 int mVideoWidth; 274 int mVideoHeight; 275 int mAudioSessionId; 276 float mSendLevel; 277 struct sockaddr_in mRetransmitEndpoint; 278 bool mRetransmitEndpointValid; 279 }; 280 281 }; // namespace android 282 283 #endif // ANDROID_MEDIAPLAYER_H 284