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