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