MediaPlayerService.h revision a7e0e8b4c429fc68eb1bd5b5a30f5b91352288f9 
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/Vector.h>
27#include <ui/SurfaceComposerClient.h>
28
29#include <media/IMediaPlayerService.h>
30#include <media/MediaPlayerInterface.h>
31
32namespace android {
33
34class IMediaRecorder;
35class IMediaMetadataRetriever;
36
37#define CALLBACK_ANTAGONIZER 0
38#if CALLBACK_ANTAGONIZER
39class Antagonizer {
40public:
41    Antagonizer(notify_callback_f cb, void* client);
42    void start() { mActive = true; }
43    void stop() { mActive = false; }
44    void kill();
45private:
46    static const int interval;
47    Antagonizer();
48    static int callbackThread(void* cookie);
49    Mutex               mLock;
50    Condition           mCondition;
51    bool                mExit;
52    bool                mActive;
53    void*               mClient;
54    notify_callback_f   mCb;
55};
56#endif
57
58class MediaPlayerService : public BnMediaPlayerService
59{
60    class Client;
61
62    class AudioOutput : public MediaPlayerBase::AudioSink
63    {
64    public:
65                                AudioOutput();
66        virtual                 ~AudioOutput();
67
68        virtual bool            ready() const { return mTrack != NULL; }
69        virtual bool            realtime() const { return true; }
70        virtual ssize_t         bufferSize() const;
71        virtual ssize_t         frameCount() const;
72        virtual ssize_t         channelCount() const;
73        virtual ssize_t         frameSize() const;
74        virtual uint32_t        latency() const;
75        virtual float           msecsPerFrame() const;
76        virtual status_t        open(uint32_t sampleRate, int channelCount, int format, int bufferCount=4);
77        virtual void            start();
78        virtual ssize_t         write(const void* buffer, size_t size);
79        virtual void            stop();
80        virtual void            flush();
81        virtual void            pause();
82        virtual void            close();
83                void            setAudioStreamType(int streamType) { mStreamType = streamType; }
84                void            setVolume(float left, float right);
85        virtual status_t        dump(int fd, const Vector<String16>& args) const;
86
87        static bool             isOnEmulator();
88        static int              getMinBufferCount();
89    private:
90        static void             setMinBufferCount();
91
92        AudioTrack*             mTrack;
93        int                     mStreamType;
94        float                   mLeftVolume;
95        float                   mRightVolume;
96        float                   mMsecsPerFrame;
97        uint32_t                mLatency;
98
99        // TODO: Find real cause of Audio/Video delay in PV framework and remove this workaround
100        static const uint32_t   kAudioVideoDelayMs;
101        static bool             mIsOnEmulator;
102        static int              mMinBufferCount;  // 12 for emulator; otherwise 4
103
104    };
105
106    class AudioCache : public MediaPlayerBase::AudioSink
107    {
108    public:
109                                AudioCache(const char* name);
110        virtual                 ~AudioCache() {}
111
112        virtual bool            ready() const { return (mChannelCount > 0) && (mHeap->getHeapID() > 0); }
113        virtual bool            realtime() const { return false; }
114        virtual ssize_t         bufferSize() const { return frameSize() * mFrameCount; }
115        virtual ssize_t         frameCount() const { return mFrameCount; }
116        virtual ssize_t         channelCount() const { return (ssize_t)mChannelCount; }
117        virtual ssize_t         frameSize() const { return ssize_t(mChannelCount * ((mFormat == AudioSystem::PCM_16_BIT)?sizeof(int16_t):sizeof(u_int8_t))); }
118        virtual uint32_t        latency() const;
119        virtual float           msecsPerFrame() const;
120        virtual status_t        open(uint32_t sampleRate, int channelCount, int format, int bufferCount=1);
121        virtual void            start() {}
122        virtual ssize_t         write(const void* buffer, size_t size);
123        virtual void            stop() {}
124        virtual void            flush() {}
125        virtual void            pause() {}
126        virtual void            close() {}
127                void            setAudioStreamType(int streamType) {}
128                void            setVolume(float left, float right) {}
129                uint32_t        sampleRate() const { return mSampleRate; }
130                uint32_t        format() const { return (uint32_t)mFormat; }
131                size_t          size() const { return mSize; }
132                status_t        wait();
133
134                sp<IMemoryHeap> getHeap() const { return mHeap; }
135
136        static  void            notify(void* cookie, int msg, int ext1, int ext2);
137        virtual status_t        dump(int fd, const Vector<String16>& args) const;
138
139    private:
140                                AudioCache();
141
142        Mutex               mLock;
143        Condition           mSignal;
144        sp<MemoryHeapBase>  mHeap;
145        float               mMsecsPerFrame;
146        uint16_t            mChannelCount;
147        uint16_t            mFormat;
148        ssize_t             mFrameCount;
149        uint32_t            mSampleRate;
150        uint32_t            mSize;
151        int                 mError;
152        bool                mCommandComplete;
153    };
154
155public:
156    static  void                instantiate();
157
158    // IMediaPlayerService interface
159    virtual sp<IMediaRecorder>  createMediaRecorder(pid_t pid);
160    virtual sp<IMediaMetadataRetriever> createMetadataRetriever(pid_t pid);
161
162    // House keeping for media player clients
163    virtual sp<IMediaPlayer>    create(pid_t pid, const sp<IMediaPlayerClient>& client, const char* url);
164    virtual sp<IMediaPlayer>    create(pid_t pid, const sp<IMediaPlayerClient>& client, int fd, int64_t offset, int64_t length);
165    virtual sp<IMemory>         decode(const char* url, uint32_t *pSampleRate, int* pNumChannels, int* pFormat);
166    virtual sp<IMemory>         decode(int fd, int64_t offset, int64_t length, uint32_t *pSampleRate, int* pNumChannels, int* pFormat);
167
168    virtual status_t            dump(int fd, const Vector<String16>& args);
169
170            void                removeClient(wp<Client> client);
171
172
173private:
174
175    class Client : public BnMediaPlayer {
176
177        // IMediaPlayer interface
178        virtual void            disconnect();
179        virtual status_t        setVideoSurface(const sp<ISurface>& surface);
180        virtual status_t        prepareAsync();
181        virtual status_t        start();
182        virtual status_t        stop();
183        virtual status_t        pause();
184        virtual status_t        isPlaying(bool* state);
185        virtual status_t        seekTo(int msec);
186        virtual status_t        getCurrentPosition(int* msec);
187        virtual status_t        getDuration(int* msec);
188        virtual status_t        reset();
189        virtual status_t        setAudioStreamType(int type);
190        virtual status_t        setLooping(int loop);
191        virtual status_t        setVolume(float leftVolume, float rightVolume);
192        virtual status_t        invoke(const Parcel& request, Parcel *reply);
193        virtual status_t        setMetadataFilter(const Parcel& filter);
194
195        sp<MediaPlayerBase>     createPlayer(player_type playerType);
196                status_t        setDataSource(const char *url);
197                status_t        setDataSource(int fd, int64_t offset, int64_t length);
198        static  void            notify(void* cookie, int msg, int ext1, int ext2);
199
200                pid_t           pid() const { return mPid; }
201        virtual status_t        dump(int fd, const Vector<String16>& args) const;
202
203    private:
204        friend class MediaPlayerService;
205                                Client( const sp<MediaPlayerService>& service,
206                                        pid_t pid,
207                                        int32_t connId,
208                                        const sp<IMediaPlayerClient>& client);
209                                Client();
210        virtual                 ~Client();
211
212                void            deletePlayer();
213
214        sp<MediaPlayerBase>     getPlayer() const { Mutex::Autolock lock(mLock); return mPlayer; }
215
216
217        /**
218         * @return true if the metadata should be dropped.
219         */
220        bool shouldDropMetadata(int code) const;
221
222        mutable     Mutex                       mLock;
223                    sp<MediaPlayerBase>         mPlayer;
224                    sp<MediaPlayerService>      mService;
225                    sp<IMediaPlayerClient>      mClient;
226                    sp<AudioOutput>             mAudioOutput;
227                    pid_t                       mPid;
228                    status_t                    mStatus;
229                    bool                        mLoop;
230                    int32_t                     mConnId;
231        // FIXME: Replace Vector<> with std::set<> when available. std::set support find.
232        // Metadata filters.
233                    Vector<int32_t>             mMetadataAllow;  // protected by mLock
234                    Vector<int32_t>             mMetadataDrop;  // protected by mLock
235#if CALLBACK_ANTAGONIZER
236                    Antagonizer*                mAntagonizer;
237#endif
238    };
239
240// ----------------------------------------------------------------------------
241
242                            MediaPlayerService();
243    virtual                 ~MediaPlayerService();
244
245    mutable     Mutex                       mLock;
246                SortedVector< wp<Client> >  mClients;
247                int32_t                     mNextConnId;
248};
249
250// ----------------------------------------------------------------------------
251
252}; // namespace android
253
254#endif // ANDROID_MEDIAPLAYERSERVICE_H
255