MediaPlayerService.h revision 2729ea9262ca60d93047e984739887cfc89e82eb
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.h> 22#include <utils/KeyedVector.h> 23#include <ui/SurfaceComposerClient.h> 24 25#include <media/IMediaPlayerService.h> 26#include <media/MediaPlayerInterface.h> 27 28class SkBitmap; 29 30namespace android { 31 32#define CALLBACK_ANTAGONIZER 0 33#if CALLBACK_ANTAGONIZER 34class Antagonizer { 35public: 36 Antagonizer(notify_callback_f cb, void* client); 37 void start() { mActive = true; } 38 void stop() { mActive = false; } 39 void kill(); 40private: 41 static const int interval; 42 Antagonizer(); 43 static int callbackThread(void* cookie); 44 Mutex mLock; 45 Condition mCondition; 46 bool mExit; 47 bool mActive; 48 void* mClient; 49 notify_callback_f mCb; 50}; 51#endif 52 53class MediaPlayerService : public BnMediaPlayerService 54{ 55 class Client; 56 57 class AudioOutput : public MediaPlayerBase::AudioSink 58 { 59 public: 60 AudioOutput(); 61 virtual ~AudioOutput(); 62 63 virtual bool ready() const { return mTrack != NULL; } 64 virtual bool realtime() const { return true; } 65 virtual ssize_t bufferSize() const; 66 virtual ssize_t frameCount() const; 67 virtual ssize_t channelCount() const; 68 virtual ssize_t frameSize() const; 69 virtual uint32_t latency() const; 70 virtual float msecsPerFrame() const; 71 virtual status_t open(uint32_t sampleRate, int channelCount, int bufferCount=4); 72 virtual void start(); 73 virtual ssize_t write(const void* buffer, size_t size); 74 virtual void stop(); 75 virtual void flush(); 76 virtual void pause(); 77 virtual void close(); 78 void setAudioStreamType(int streamType) { mStreamType = streamType; } 79 void setVolume(float left, float right); 80 virtual status_t dump(int fd, const Vector<String16>& args) const; 81 private: 82 AudioTrack* mTrack; 83 int mStreamType; 84 float mLeftVolume; 85 float mRightVolume; 86 float mMsecsPerFrame; 87 uint32_t mLatency; 88 static const uint32_t kDriverLatencyInMsecs; 89 }; 90 91 class AudioCache : public MediaPlayerBase::AudioSink 92 { 93 public: 94 AudioCache(const char* name); 95 virtual ~AudioCache() {} 96 97 virtual bool ready() const { return (mChannelCount > 0) && (mHeap->getHeapID() > 0); } 98 virtual bool realtime() const { return false; } 99 virtual ssize_t bufferSize() const { return 4096; } 100 virtual ssize_t frameCount() const { return mFrameCount; } 101 virtual ssize_t channelCount() const { return mChannelCount; } 102 virtual ssize_t frameSize() const { return ssize_t(mChannelCount * sizeof(int16_t)); } 103 virtual uint32_t latency() const; 104 virtual float msecsPerFrame() const; 105 virtual status_t open(uint32_t sampleRate, int channelCount, int bufferCount=1); 106 virtual void start() {} 107 virtual ssize_t write(const void* buffer, size_t size); 108 virtual void stop() {} 109 virtual void flush() {} 110 virtual void pause() {} 111 virtual void close() {} 112 void setAudioStreamType(int streamType) {} 113 void setVolume(float left, float right) {} 114 uint32_t sampleRate() const { return mSampleRate; } 115 size_t size() const { return mSize; } 116 status_t wait(); 117 118 sp<IMemoryHeap> getHeap() const { return mHeap; } 119 120 static void notify(void* cookie, int msg, int ext1, int ext2); 121 virtual status_t dump(int fd, const Vector<String16>& args) const; 122 123 private: 124 AudioCache(); 125 126 Mutex mLock; 127 Condition mSignal; 128 sp<MemoryHeapBase> mHeap; 129 float mMsecsPerFrame; 130 ssize_t mChannelCount; 131 ssize_t mFrameCount; 132 uint32_t mSampleRate; 133 uint32_t mSize; 134 int mError; 135 bool mCommandComplete; 136 }; 137 138public: 139 static void instantiate(); 140 141 // IMediaPlayerService interface 142 virtual sp<IMediaPlayer> create(pid_t pid, const sp<IMediaPlayerClient>& client, const char* url); 143 virtual sp<IMediaPlayer> create(pid_t pid, const sp<IMediaPlayerClient>& client, int fd, int64_t offset, int64_t length); 144 virtual sp<IMemory> decode(const char* url, uint32_t *pSampleRate, int* pNumChannels); 145 virtual sp<IMemory> decode(int fd, int64_t offset, int64_t length, uint32_t *pSampleRate, int* pNumChannels); 146 147 virtual status_t dump(int fd, const Vector<String16>& args); 148 149 void removeClient(wp<Client> client); 150 151private: 152 153 class Client : public BnMediaPlayer { 154 155 // IMediaPlayer interface 156 virtual void disconnect(); 157 virtual status_t setVideoSurface(const sp<ISurface>& surface); 158 virtual status_t prepareAsync(); 159 virtual status_t start(); 160 virtual status_t stop(); 161 virtual status_t pause(); 162 virtual status_t isPlaying(bool* state); 163 virtual status_t getVideoSize(int* w, int* h); 164 virtual status_t seekTo(int msec); 165 virtual status_t getCurrentPosition(int* msec); 166 virtual status_t getDuration(int* msec); 167 virtual status_t reset(); 168 virtual status_t setAudioStreamType(int type); 169 virtual status_t setLooping(int loop); 170 virtual status_t setVolume(float leftVolume, float rightVolume); 171 172 sp<MediaPlayerBase> createPlayer(player_type playerType); 173 status_t setDataSource(const char *url); 174 status_t setDataSource(int fd, int64_t offset, int64_t length); 175 static void notify(void* cookie, int msg, int ext1, int ext2); 176 177 pid_t pid() const { return mPid; } 178 virtual status_t dump(int fd, const Vector<String16>& args) const; 179 180 private: 181 friend class MediaPlayerService; 182 Client( const sp<MediaPlayerService>& service, 183 pid_t pid, 184 int32_t connId, 185 const sp<IMediaPlayerClient>& client); 186 Client(); 187 virtual ~Client(); 188 189 void deletePlayer(); 190 191 sp<MediaPlayerBase> getPlayer() const { Mutex::Autolock lock(mLock); return mPlayer; } 192 193 mutable Mutex mLock; 194 sp<MediaPlayerBase> mPlayer; 195 sp<MediaPlayerService> mService; 196 sp<IMediaPlayerClient> mClient; 197 sp<AudioOutput> mAudioOutput; 198 pid_t mPid; 199 status_t mStatus; 200 bool mLoop; 201 int32_t mConnId; 202#if CALLBACK_ANTAGONIZER 203 Antagonizer* mAntagonizer; 204#endif 205 }; 206 207// ---------------------------------------------------------------------------- 208 209 MediaPlayerService(); 210 virtual ~MediaPlayerService(); 211 212 mutable Mutex mLock; 213 SortedVector< wp<Client> > mClients; 214 int32_t mNextConnId; 215}; 216 217// ---------------------------------------------------------------------------- 218 219}; // namespace android 220 221#endif // ANDROID_MEDIAPLAYERSERVICE_H 222 223