MediaPlayerService.h revision 7a8b0ed6419e57dd8b41d3806893d63d3df91aab
1/* 2** 3** Copyright 2008, 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#ifndef ANDROID_MEDIAPLAYERSERVICE_H 19#define ANDROID_MEDIAPLAYERSERVICE_H 20 21#include <utils/Log.h> 22#include <utils/threads.h> 23#include <utils/List.h> 24#include <utils/Errors.h> 25#include <utils/KeyedVector.h> 26#include <utils/String8.h> 27#include <utils/Vector.h> 28 29#include <media/IMediaPlayerService.h> 30#include <media/MediaPlayerInterface.h> 31#include <media/Metadata.h> 32 33#include <system/audio.h> 34 35namespace android { 36 37class AudioTrack; 38class IMediaRecorder; 39class IMediaMetadataRetriever; 40class IOMX; 41class MediaRecorderClient; 42 43#define CALLBACK_ANTAGONIZER 0 44#if CALLBACK_ANTAGONIZER 45class Antagonizer { 46public: 47 Antagonizer(notify_callback_f cb, void* client); 48 void start() { mActive = true; } 49 void stop() { mActive = false; } 50 void kill(); 51private: 52 static const int interval; 53 Antagonizer(); 54 static int callbackThread(void* cookie); 55 Mutex mLock; 56 Condition mCondition; 57 bool mExit; 58 bool mActive; 59 void* mClient; 60 notify_callback_f mCb; 61}; 62#endif 63 64class MediaPlayerService : public BnMediaPlayerService 65{ 66 class Client; 67 68 class AudioOutput : public MediaPlayerBase::AudioSink 69 { 70 public: 71 AudioOutput(int sessionId); 72 virtual ~AudioOutput(); 73 74 virtual bool ready() const { return mTrack != NULL; } 75 virtual bool realtime() const { return true; } 76 virtual ssize_t bufferSize() const; 77 virtual ssize_t frameCount() const; 78 virtual ssize_t channelCount() const; 79 virtual ssize_t frameSize() const; 80 virtual uint32_t latency() const; 81 virtual float msecsPerFrame() const; 82 virtual status_t getPosition(uint32_t *position); 83 virtual int getSessionId(); 84 85 virtual status_t open( 86 uint32_t sampleRate, int channelCount, 87 audio_format_t format, int bufferCount, 88 AudioCallback cb, void *cookie); 89 90 virtual void start(); 91 virtual ssize_t write(const void* buffer, size_t size); 92 virtual void stop(); 93 virtual void flush(); 94 virtual void pause(); 95 virtual void close(); 96 void setAudioStreamType(audio_stream_type_t streamType) { mStreamType = streamType; } 97 void setVolume(float left, float right); 98 virtual status_t setPlaybackRatePermille(int32_t ratePermille); 99 status_t setAuxEffectSendLevel(float level); 100 status_t attachAuxEffect(int effectId); 101 virtual status_t dump(int fd, const Vector<String16>& args) const; 102 103 static bool isOnEmulator(); 104 static int getMinBufferCount(); 105 private: 106 static void setMinBufferCount(); 107 static void CallbackWrapper( 108 int event, void *me, void *info); 109 110 AudioTrack* mTrack; 111 AudioCallback mCallback; 112 void * mCallbackCookie; 113 audio_stream_type_t mStreamType; 114 float mLeftVolume; 115 float mRightVolume; 116 int32_t mPlaybackRatePermille; 117 uint32_t mSampleRateHz; // sample rate of the content, as set in open() 118 float mMsecsPerFrame; 119 uint32_t mLatency; 120 int mSessionId; 121 float mSendLevel; 122 int mAuxEffectId; 123 static bool mIsOnEmulator; 124 static int mMinBufferCount; // 12 for emulator; otherwise 4 125 126 }; 127 128 class AudioCache : public MediaPlayerBase::AudioSink 129 { 130 public: 131 AudioCache(const char* name); 132 virtual ~AudioCache() {} 133 134 virtual bool ready() const { return (mChannelCount > 0) && (mHeap->getHeapID() > 0); } 135 virtual bool realtime() const { return false; } 136 virtual ssize_t bufferSize() const { return frameSize() * mFrameCount; } 137 virtual ssize_t frameCount() const { return mFrameCount; } 138 virtual ssize_t channelCount() const { return (ssize_t)mChannelCount; } 139 virtual ssize_t frameSize() const { return ssize_t(mChannelCount * ((mFormat == AUDIO_FORMAT_PCM_16_BIT)?sizeof(int16_t):sizeof(u_int8_t))); } 140 virtual uint32_t latency() const; 141 virtual float msecsPerFrame() const; 142 virtual status_t getPosition(uint32_t *position); 143 virtual int getSessionId(); 144 145 virtual status_t open( 146 uint32_t sampleRate, int channelCount, audio_format_t format, 147 int bufferCount = 1, 148 AudioCallback cb = NULL, void *cookie = NULL); 149 150 virtual void start(); 151 virtual ssize_t write(const void* buffer, size_t size); 152 virtual void stop(); 153 virtual void flush() {} 154 virtual void pause() {} 155 virtual void close() {} 156 void setAudioStreamType(audio_stream_type_t streamType) {} 157 void setVolume(float left, float right) {} 158 virtual status_t setPlaybackRatePermille(int32_t ratePermille) { return INVALID_OPERATION; } 159 uint32_t sampleRate() const { return mSampleRate; } 160 audio_format_t format() const { return mFormat; } 161 size_t size() const { return mSize; } 162 status_t wait(); 163 164 sp<IMemoryHeap> getHeap() const { return mHeap; } 165 166 static void notify(void* cookie, int msg, 167 int ext1, int ext2, const Parcel *obj); 168 virtual status_t dump(int fd, const Vector<String16>& args) const; 169 170 private: 171 AudioCache(); 172 173 Mutex mLock; 174 Condition mSignal; 175 sp<MemoryHeapBase> mHeap; 176 float mMsecsPerFrame; 177 uint16_t mChannelCount; 178 audio_format_t mFormat; 179 ssize_t mFrameCount; 180 uint32_t mSampleRate; 181 uint32_t mSize; 182 int mError; 183 bool mCommandComplete; 184 185 sp<Thread> mCallbackThread; 186 }; 187 188public: 189 static void instantiate(); 190 191 // IMediaPlayerService interface 192 virtual sp<IMediaRecorder> createMediaRecorder(pid_t pid); 193 void removeMediaRecorderClient(wp<MediaRecorderClient> client); 194 virtual sp<IMediaMetadataRetriever> createMetadataRetriever(pid_t pid); 195 196 virtual sp<IMediaPlayer> create(pid_t pid, const sp<IMediaPlayerClient>& client, int audioSessionId); 197 198 virtual sp<IMemory> decode(const char* url, uint32_t *pSampleRate, int* pNumChannels, audio_format_t* pFormat); 199 virtual sp<IMemory> decode(int fd, int64_t offset, int64_t length, uint32_t *pSampleRate, int* pNumChannels, audio_format_t* pFormat); 200 virtual sp<IOMX> getOMX(); 201 202 virtual status_t dump(int fd, const Vector<String16>& args); 203 204 void removeClient(wp<Client> client); 205 206 // For battery usage tracking purpose 207 struct BatteryUsageInfo { 208 // how many streams are being played by one UID 209 int refCount; 210 // a temp variable to store the duration(ms) of audio codecs 211 // when we start a audio codec, we minus the system time from audioLastTime 212 // when we pause it, we add the system time back to the audioLastTime 213 // so after the pause, audioLastTime = pause time - start time 214 // if multiple audio streams are played (or recorded), then audioLastTime 215 // = the total playing time of all the streams 216 int32_t audioLastTime; 217 // when all the audio streams are being paused, we assign audioLastTime to 218 // this variable, so this value could be provided to the battery app 219 // in the next pullBatteryData call 220 int32_t audioTotalTime; 221 222 int32_t videoLastTime; 223 int32_t videoTotalTime; 224 }; 225 KeyedVector<int, BatteryUsageInfo> mBatteryData; 226 227 enum { 228 SPEAKER, 229 OTHER_AUDIO_DEVICE, 230 SPEAKER_AND_OTHER, 231 NUM_AUDIO_DEVICES 232 }; 233 234 struct BatteryAudioFlingerUsageInfo { 235 int refCount; // how many audio streams are being played 236 int deviceOn[NUM_AUDIO_DEVICES]; // whether the device is currently used 237 int32_t lastTime[NUM_AUDIO_DEVICES]; // in ms 238 // totalTime[]: total time of audio output devices usage 239 int32_t totalTime[NUM_AUDIO_DEVICES]; // in ms 240 }; 241 242 // This varialble is used to record the usage of audio output device 243 // for battery app 244 BatteryAudioFlingerUsageInfo mBatteryAudio; 245 246 // Collect info of the codec usage from media player and media recorder 247 virtual void addBatteryData(uint32_t params); 248 // API for the Battery app to pull the data of codecs usage 249 virtual status_t pullBatteryData(Parcel* reply); 250private: 251 252 class Client : public BnMediaPlayer { 253 254 // IMediaPlayer interface 255 virtual void disconnect(); 256 virtual status_t setVideoSurfaceTexture( 257 const sp<ISurfaceTexture>& surfaceTexture); 258 virtual status_t prepareAsync(); 259 virtual status_t start(); 260 virtual status_t stop(); 261 virtual status_t pause(); 262 virtual status_t isPlaying(bool* state); 263 virtual status_t seekTo(int msec); 264 virtual status_t getCurrentPosition(int* msec); 265 virtual status_t getDuration(int* msec); 266 virtual status_t reset(); 267 virtual status_t setAudioStreamType(audio_stream_type_t type); 268 virtual status_t setLooping(int loop); 269 virtual status_t setVolume(float leftVolume, float rightVolume); 270 virtual status_t invoke(const Parcel& request, Parcel *reply); 271 virtual status_t setMetadataFilter(const Parcel& filter); 272 virtual status_t getMetadata(bool update_only, 273 bool apply_filter, 274 Parcel *reply); 275 virtual status_t setAuxEffectSendLevel(float level); 276 virtual status_t attachAuxEffect(int effectId); 277 virtual status_t setParameter(int key, const Parcel &request); 278 virtual status_t getParameter(int key, Parcel *reply); 279 280 sp<MediaPlayerBase> createPlayer(player_type playerType); 281 282 virtual status_t setDataSource( 283 const char *url, 284 const KeyedVector<String8, String8> *headers); 285 286 virtual status_t setDataSource(int fd, int64_t offset, int64_t length); 287 288 virtual status_t setDataSource(const sp<IStreamSource> &source); 289 290 static void notify(void* cookie, int msg, 291 int ext1, int ext2, const Parcel *obj); 292 293 pid_t pid() const { return mPid; } 294 virtual status_t dump(int fd, const Vector<String16>& args) const; 295 296 int getAudioSessionId() { return mAudioSessionId; } 297 298 private: 299 friend class MediaPlayerService; 300 Client( const sp<MediaPlayerService>& service, 301 pid_t pid, 302 int32_t connId, 303 const sp<IMediaPlayerClient>& client, 304 int audioSessionId, 305 uid_t uid); 306 Client(); 307 virtual ~Client(); 308 309 void deletePlayer(); 310 311 sp<MediaPlayerBase> getPlayer() const { Mutex::Autolock lock(mLock); return mPlayer; } 312 313 314 315 // @param type Of the metadata to be tested. 316 // @return true if the metadata should be dropped according to 317 // the filters. 318 bool shouldDropMetadata(media::Metadata::Type type) const; 319 320 // Add a new element to the set of metadata updated. Noop if 321 // the element exists already. 322 // @param type Of the metadata to be recorded. 323 void addNewMetadataUpdate(media::Metadata::Type type); 324 325 // Disconnect from the currently connected ANativeWindow. 326 void disconnectNativeWindow(); 327 328 mutable Mutex mLock; 329 sp<MediaPlayerBase> mPlayer; 330 sp<MediaPlayerService> mService; 331 sp<IMediaPlayerClient> mClient; 332 sp<AudioOutput> mAudioOutput; 333 pid_t mPid; 334 status_t mStatus; 335 bool mLoop; 336 int32_t mConnId; 337 int mAudioSessionId; 338 uid_t mUID; 339 sp<ANativeWindow> mConnectedWindow; 340 sp<IBinder> mConnectedWindowBinder; 341 342 // Metadata filters. 343 media::Metadata::Filter mMetadataAllow; // protected by mLock 344 media::Metadata::Filter mMetadataDrop; // protected by mLock 345 346 // Metadata updated. For each MEDIA_INFO_METADATA_UPDATE 347 // notification we try to update mMetadataUpdated which is a 348 // set: no duplicate. 349 // getMetadata clears this set. 350 media::Metadata::Filter mMetadataUpdated; // protected by mLock 351 352#if CALLBACK_ANTAGONIZER 353 Antagonizer* mAntagonizer; 354#endif 355 }; 356 357// ---------------------------------------------------------------------------- 358 359 MediaPlayerService(); 360 virtual ~MediaPlayerService(); 361 362 mutable Mutex mLock; 363 SortedVector< wp<Client> > mClients; 364 SortedVector< wp<MediaRecorderClient> > mMediaRecorderClients; 365 int32_t mNextConnId; 366 sp<IOMX> mOMX; 367}; 368 369// ---------------------------------------------------------------------------- 370 371}; // namespace android 372 373#endif // ANDROID_MEDIAPLAYERSERVICE_H 374