blob: e9f72b8212fa1b1ed77bd5dca07fcc246ac69c08 [file] [log] [blame]
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001/*
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
John Grossmanc795b642012-02-22 15:38:35 -080021#include <arpa/inet.h>
22
Mathias Agopian273d0982009-05-31 19:13:00 -070023#include <utils/threads.h>
Mathias Agopian273d0982009-05-31 19:13:00 -070024#include <utils/Errors.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080025#include <utils/KeyedVector.h>
Andreas Huber2db84552010-01-28 11:19:57 -080026#include <utils/String8.h>
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -070027#include <utils/Vector.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080028
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080029#include <media/MediaPlayerInterface.h>
nikoa64c8c72009-07-20 15:07:26 -070030#include <media/Metadata.h>
Marco Nelissen6b74d672012-02-28 16:07:44 -080031#include <media/stagefright/foundation/ABase.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080032
Dima Zavin64760242011-05-11 14:15:23 -070033#include <system/audio.h>
Dima Zavinfce7a472011-04-19 22:30:36 -070034
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080035namespace android {
36
Lajos Molnar3a474aa2015-04-24 17:10:07 -070037struct AudioPlaybackRate;
Glenn Kastena3f1fa32012-01-18 14:54:46 -080038class AudioTrack;
Lajos Molnar3a474aa2015-04-24 17:10:07 -070039struct AVSyncSettings;
Chris Watkins99f31602015-03-20 13:06:33 -070040class IDataSource;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080041class IMediaRecorder;
42class IMediaMetadataRetriever;
Andreas Huber20111aa2009-07-14 16:56:47 -070043class IOMX;
Jeff Brown2013a542012-09-04 21:38:42 -070044class IRemoteDisplay;
45class IRemoteDisplayClient;
Gloria Wangdac6a312009-10-29 15:46:37 -070046class MediaRecorderClient;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080047
48#define CALLBACK_ANTAGONIZER 0
49#if CALLBACK_ANTAGONIZER
50class Antagonizer {
51public:
52 Antagonizer(notify_callback_f cb, void* client);
53 void start() { mActive = true; }
54 void stop() { mActive = false; }
55 void kill();
56private:
57 static const int interval;
58 Antagonizer();
59 static int callbackThread(void* cookie);
60 Mutex mLock;
61 Condition mCondition;
62 bool mExit;
63 bool mActive;
64 void* mClient;
65 notify_callback_f mCb;
66};
67#endif
68
69class MediaPlayerService : public BnMediaPlayerService
70{
71 class Client;
72
73 class AudioOutput : public MediaPlayerBase::AudioSink
74 {
Marco Nelissen6b74d672012-02-28 16:07:44 -080075 class CallbackData;
76
77 public:
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -070078 AudioOutput(int sessionId, int uid, int pid,
79 const audio_attributes_t * attr);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080080 virtual ~AudioOutput();
81
Glenn Kasten2799d742013-05-30 14:33:29 -070082 virtual bool ready() const { return mTrack != 0; }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080083 virtual ssize_t bufferSize() const;
84 virtual ssize_t frameCount() const;
85 virtual ssize_t channelCount() const;
86 virtual ssize_t frameSize() const;
87 virtual uint32_t latency() const;
88 virtual float msecsPerFrame() const;
Marco Nelissen4110c102012-03-29 09:31:28 -070089 virtual status_t getPosition(uint32_t *position) const;
Lajos Molnar06ad1522014-08-28 07:27:44 -070090 virtual status_t getTimestamp(AudioTimestamp &ts) const;
Marco Nelissen4110c102012-03-29 09:31:28 -070091 virtual status_t getFramesWritten(uint32_t *frameswritten) const;
92 virtual int getSessionId() const;
Eric Laurent6f59db12013-07-26 17:16:50 -070093 virtual uint32_t getSampleRate() const;
Andreas Huber20111aa2009-07-14 16:56:47 -070094
95 virtual status_t open(
Jean-Michel Trivi786618f2012-03-02 14:54:07 -080096 uint32_t sampleRate, int channelCount, audio_channel_mask_t channelMask,
Glenn Kastene1c39622012-01-04 09:36:37 -080097 audio_format_t format, int bufferCount,
Eric Laurent1948eb32012-04-13 16:50:19 -070098 AudioCallback cb, void *cookie,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +000099 audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE,
Ronghua Wufaeb0f22015-05-21 12:20:21 -0700100 const audio_offload_info_t *offloadInfo = NULL,
101 bool doNotReconnect = false);
Andreas Huber20111aa2009-07-14 16:56:47 -0700102
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +0100103 virtual status_t start();
Wei Jia7d3f4df2015-03-03 15:28:00 -0800104 virtual ssize_t write(const void* buffer, size_t size, bool blocking = true);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800105 virtual void stop();
106 virtual void flush();
107 virtual void pause();
108 virtual void close();
Eric Laurent22612342013-11-14 17:28:47 -0800109 void setAudioStreamType(audio_stream_type_t streamType) {
110 mStreamType = streamType; }
111 virtual audio_stream_type_t getAudioStreamType() const { return mStreamType; }
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700112 void setAudioAttributes(const audio_attributes_t * attributes);
Eric Laurent22612342013-11-14 17:28:47 -0800113
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800114 void setVolume(float left, float right);
Lajos Molnar3a474aa2015-04-24 17:10:07 -0700115 virtual status_t setPlaybackRate(const AudioPlaybackRate& rate);
116 virtual status_t getPlaybackRate(AudioPlaybackRate* rate /* nonnull */);
117
Eric Laurent2beeb502010-07-16 07:43:46 -0700118 status_t setAuxEffectSendLevel(float level);
119 status_t attachAuxEffect(int effectId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800120 virtual status_t dump(int fd, const Vector<String16>& args) const;
121
122 static bool isOnEmulator();
123 static int getMinBufferCount();
Marco Nelissen6b74d672012-02-28 16:07:44 -0800124 void setNextOutput(const sp<AudioOutput>& nextOutput);
125 void switchToNextOutput();
126 virtual bool needsTrailingPadding() { return mNextOutput == NULL; }
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +0100127 virtual status_t setParameters(const String8& keyValuePairs);
128 virtual String8 getParameters(const String8& keys);
Marco Nelissen6b74d672012-02-28 16:07:44 -0800129
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800130 private:
131 static void setMinBufferCount();
Andreas Huber20111aa2009-07-14 16:56:47 -0700132 static void CallbackWrapper(
Glenn Kastend217a8c2011-06-01 15:20:35 -0700133 int event, void *me, void *info);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +0100134 void deleteRecycledTrack();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800135
Glenn Kasten2799d742013-05-30 14:33:29 -0700136 sp<AudioTrack> mTrack;
137 sp<AudioTrack> mRecycledTrack;
Marco Nelissen6b74d672012-02-28 16:07:44 -0800138 sp<AudioOutput> mNextOutput;
Andreas Huber20111aa2009-07-14 16:56:47 -0700139 AudioCallback mCallback;
140 void * mCallbackCookie;
Marco Nelissen6b74d672012-02-28 16:07:44 -0800141 CallbackData * mCallbackData;
Marco Nelissen4110c102012-03-29 09:31:28 -0700142 uint64_t mBytesWritten;
Glenn Kastenfff6d712012-01-12 16:38:12 -0800143 audio_stream_type_t mStreamType;
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700144 const audio_attributes_t *mAttributes;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800145 float mLeftVolume;
146 float mRightVolume;
Lajos Molnar3a474aa2015-04-24 17:10:07 -0700147 AudioPlaybackRate mPlaybackRate;
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -0800148 uint32_t mSampleRateHz; // sample rate of the content, as set in open()
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800149 float mMsecsPerFrame;
Eric Laurenta514bdb2010-06-21 09:27:30 -0700150 int mSessionId;
Marco Nelissen9cae2172013-01-14 14:12:05 -0800151 int mUid;
Marco Nelissend457c972014-02-11 08:47:07 -0800152 int mPid;
Eric Laurent2beeb502010-07-16 07:43:46 -0700153 float mSendLevel;
154 int mAuxEffectId;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800155 static bool mIsOnEmulator;
156 static int mMinBufferCount; // 12 for emulator; otherwise 4
Eric Laurent1948eb32012-04-13 16:50:19 -0700157 audio_output_flags_t mFlags;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800158
Marco Nelissen6b74d672012-02-28 16:07:44 -0800159 // CallbackData is what is passed to the AudioTrack as the "user" data.
160 // We need to be able to target this to a different Output on the fly,
161 // so we can't use the Output itself for this.
162 class CallbackData {
163 public:
164 CallbackData(AudioOutput *cookie) {
165 mData = cookie;
166 mSwitching = false;
167 }
168 AudioOutput * getOutput() { return mData;}
169 void setOutput(AudioOutput* newcookie) { mData = newcookie; }
170 // lock/unlock are used by the callback before accessing the payload of this object
171 void lock() { mLock.lock(); }
172 void unlock() { mLock.unlock(); }
173 // beginTrackSwitch/endTrackSwitch are used when this object is being handed over
174 // to the next sink.
175 void beginTrackSwitch() { mLock.lock(); mSwitching = true; }
176 void endTrackSwitch() {
177 if (mSwitching) {
178 mLock.unlock();
179 }
180 mSwitching = false;
181 }
182 private:
183 AudioOutput * mData;
184 mutable Mutex mLock;
185 bool mSwitching;
186 DISALLOW_EVIL_CONSTRUCTORS(CallbackData);
187 };
188
189 }; // AudioOutput
190
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800191
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800192public:
193 static void instantiate();
194
195 // IMediaPlayerService interface
Svet Ganovbe71aa22015-04-28 12:06:02 -0700196 virtual sp<IMediaRecorder> createMediaRecorder(const String16 &opPackageName);
Gloria Wangdac6a312009-10-29 15:46:37 -0700197 void removeMediaRecorderClient(wp<MediaRecorderClient> client);
Glenn Kastenf37971f2012-02-03 11:06:53 -0800198 virtual sp<IMediaMetadataRetriever> createMetadataRetriever();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800199
Glenn Kastenf37971f2012-02-03 11:06:53 -0800200 virtual sp<IMediaPlayer> create(const sp<IMediaPlayerClient>& client, int audioSessionId);
Andreas Hubere2b10282010-11-23 11:41:34 -0800201
Lajos Molnar1381d4b2014-08-07 15:18:35 -0700202 virtual sp<IMediaCodecList> getCodecList() const;
Andreas Huber318ad9c2009-10-15 13:46:54 -0700203 virtual sp<IOMX> getOMX();
Andreas Hubered3e3e02012-03-26 11:13:27 -0700204 virtual sp<ICrypto> makeCrypto();
Jeff Tinkercc82dc62013-02-08 10:18:35 -0800205 virtual sp<IDrm> makeDrm();
Andreas Huber279dcd82013-01-30 10:41:25 -0800206 virtual sp<IHDCP> makeHDCP(bool createEncryptionModule);
Jeff Brown2013a542012-09-04 21:38:42 -0700207
Svet Ganovbe71aa22015-04-28 12:06:02 -0700208 virtual sp<IRemoteDisplay> listenForRemoteDisplay(const String16 &opPackageName,
209 const sp<IRemoteDisplayClient>& client, const String8& iface);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800210 virtual status_t dump(int fd, const Vector<String16>& args);
211
212 void removeClient(wp<Client> client);
213
Gloria Wang7cf180c2011-02-19 18:37:57 -0800214 // For battery usage tracking purpose
215 struct BatteryUsageInfo {
216 // how many streams are being played by one UID
217 int refCount;
218 // a temp variable to store the duration(ms) of audio codecs
219 // when we start a audio codec, we minus the system time from audioLastTime
220 // when we pause it, we add the system time back to the audioLastTime
221 // so after the pause, audioLastTime = pause time - start time
222 // if multiple audio streams are played (or recorded), then audioLastTime
223 // = the total playing time of all the streams
224 int32_t audioLastTime;
225 // when all the audio streams are being paused, we assign audioLastTime to
226 // this variable, so this value could be provided to the battery app
227 // in the next pullBatteryData call
228 int32_t audioTotalTime;
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700229
Gloria Wang7cf180c2011-02-19 18:37:57 -0800230 int32_t videoLastTime;
231 int32_t videoTotalTime;
232 };
233 KeyedVector<int, BatteryUsageInfo> mBatteryData;
234
Gloria Wang9ee159b2011-02-24 14:51:45 -0800235 enum {
236 SPEAKER,
237 OTHER_AUDIO_DEVICE,
238 SPEAKER_AND_OTHER,
239 NUM_AUDIO_DEVICES
240 };
241
242 struct BatteryAudioFlingerUsageInfo {
243 int refCount; // how many audio streams are being played
244 int deviceOn[NUM_AUDIO_DEVICES]; // whether the device is currently used
245 int32_t lastTime[NUM_AUDIO_DEVICES]; // in ms
246 // totalTime[]: total time of audio output devices usage
247 int32_t totalTime[NUM_AUDIO_DEVICES]; // in ms
248 };
249
250 // This varialble is used to record the usage of audio output device
251 // for battery app
252 BatteryAudioFlingerUsageInfo mBatteryAudio;
253
Gloria Wang7cf180c2011-02-19 18:37:57 -0800254 // Collect info of the codec usage from media player and media recorder
255 virtual void addBatteryData(uint32_t params);
256 // API for the Battery app to pull the data of codecs usage
257 virtual status_t pullBatteryData(Parcel* reply);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800258private:
259
260 class Client : public BnMediaPlayer {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800261 // IMediaPlayer interface
262 virtual void disconnect();
Glenn Kasten11731182011-02-08 17:26:17 -0800263 virtual status_t setVideoSurfaceTexture(
Andy McFadden484566c2012-12-18 09:46:54 -0800264 const sp<IGraphicBufferProducer>& bufferProducer);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800265 virtual status_t prepareAsync();
266 virtual status_t start();
267 virtual status_t stop();
268 virtual status_t pause();
269 virtual status_t isPlaying(bool* state);
Lajos Molnar3a474aa2015-04-24 17:10:07 -0700270 virtual status_t setPlaybackSettings(const AudioPlaybackRate& rate);
271 virtual status_t getPlaybackSettings(AudioPlaybackRate* rate /* nonnull */);
272 virtual status_t setSyncSettings(const AVSyncSettings& rate, float videoFpsHint);
273 virtual status_t getSyncSettings(AVSyncSettings* rate /* nonnull */,
274 float* videoFps /* nonnull */);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800275 virtual status_t seekTo(int msec);
276 virtual status_t getCurrentPosition(int* msec);
277 virtual status_t getDuration(int* msec);
278 virtual status_t reset();
Glenn Kastenfff6d712012-01-12 16:38:12 -0800279 virtual status_t setAudioStreamType(audio_stream_type_t type);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800280 virtual status_t setLooping(int loop);
281 virtual status_t setVolume(float leftVolume, float rightVolume);
Nicolas Catania1d187f12009-05-12 23:25:55 -0700282 virtual status_t invoke(const Parcel& request, Parcel *reply);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700283 virtual status_t setMetadataFilter(const Parcel& filter);
Nicolas Catania48290382009-07-10 13:53:06 -0700284 virtual status_t getMetadata(bool update_only,
285 bool apply_filter,
286 Parcel *reply);
Eric Laurent2beeb502010-07-16 07:43:46 -0700287 virtual status_t setAuxEffectSendLevel(float level);
288 virtual status_t attachAuxEffect(int effectId);
Gloria Wang4f9e47f2011-04-25 17:28:22 -0700289 virtual status_t setParameter(int key, const Parcel &request);
290 virtual status_t getParameter(int key, Parcel *reply);
John Grossmanc795b642012-02-22 15:38:35 -0800291 virtual status_t setRetransmitEndpoint(const struct sockaddr_in* endpoint);
John Grossman44a7e422012-06-21 17:29:24 -0700292 virtual status_t getRetransmitEndpoint(struct sockaddr_in* endpoint);
Marco Nelissen6b74d672012-02-28 16:07:44 -0800293 virtual status_t setNextPlayer(const sp<IMediaPlayer>& player);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800294
295 sp<MediaPlayerBase> createPlayer(player_type playerType);
Andreas Huber2db84552010-01-28 11:19:57 -0800296
Dave Burked681bbb2011-08-30 14:39:17 +0100297 virtual status_t setDataSource(
Andreas Huber1b86fe02014-01-29 11:13:26 -0800298 const sp<IMediaHTTPService> &httpService,
Andreas Huber2db84552010-01-28 11:19:57 -0800299 const char *url,
300 const KeyedVector<String8, String8> *headers);
301
Dave Burked681bbb2011-08-30 14:39:17 +0100302 virtual status_t setDataSource(int fd, int64_t offset, int64_t length);
Andreas Hubere2b10282010-11-23 11:41:34 -0800303
Dave Burked681bbb2011-08-30 14:39:17 +0100304 virtual status_t setDataSource(const sp<IStreamSource> &source);
Chris Watkins99f31602015-03-20 13:06:33 -0700305 virtual status_t setDataSource(const sp<IDataSource> &source);
306
Andreas Hubere2b10282010-11-23 11:41:34 -0800307
John Grossmanc795b642012-02-22 15:38:35 -0800308 sp<MediaPlayerBase> setDataSource_pre(player_type playerType);
309 void setDataSource_post(const sp<MediaPlayerBase>& p,
310 status_t status);
311
Gloria Wangb483c472011-04-11 17:23:27 -0700312 static void notify(void* cookie, int msg,
313 int ext1, int ext2, const Parcel *obj);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800314
315 pid_t pid() const { return mPid; }
Lajos Molnar6d339f12015-04-17 16:15:53 -0700316 virtual status_t dump(int fd, const Vector<String16>& args);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800317
Eric Laurenta514bdb2010-06-21 09:27:30 -0700318 int getAudioSessionId() { return mAudioSessionId; }
319
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800320 private:
321 friend class MediaPlayerService;
322 Client( const sp<MediaPlayerService>& service,
323 pid_t pid,
324 int32_t connId,
Eric Laurenta514bdb2010-06-21 09:27:30 -0700325 const sp<IMediaPlayerClient>& client,
Andreas Huber9b80c2b2011-06-30 15:47:02 -0700326 int audioSessionId,
327 uid_t uid);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800328 Client();
329 virtual ~Client();
330
331 void deletePlayer();
332
333 sp<MediaPlayerBase> getPlayer() const { Mutex::Autolock lock(mLock); return mPlayer; }
334
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700335
Nicolas Catania48290382009-07-10 13:53:06 -0700336
337 // @param type Of the metadata to be tested.
338 // @return true if the metadata should be dropped according to
339 // the filters.
nikoa64c8c72009-07-20 15:07:26 -0700340 bool shouldDropMetadata(media::Metadata::Type type) const;
Nicolas Catania48290382009-07-10 13:53:06 -0700341
342 // Add a new element to the set of metadata updated. Noop if
343 // the element exists already.
344 // @param type Of the metadata to be recorded.
nikoa64c8c72009-07-20 15:07:26 -0700345 void addNewMetadataUpdate(media::Metadata::Type type);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700346
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700347 // Disconnect from the currently connected ANativeWindow.
348 void disconnectNativeWindow();
349
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700350 status_t setAudioAttributes_l(const Parcel &request);
351
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800352 mutable Mutex mLock;
353 sp<MediaPlayerBase> mPlayer;
354 sp<MediaPlayerService> mService;
355 sp<IMediaPlayerClient> mClient;
356 sp<AudioOutput> mAudioOutput;
357 pid_t mPid;
358 status_t mStatus;
359 bool mLoop;
360 int32_t mConnId;
Eric Laurenta514bdb2010-06-21 09:27:30 -0700361 int mAudioSessionId;
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700362 audio_attributes_t * mAudioAttributes;
Andreas Huber9b80c2b2011-06-30 15:47:02 -0700363 uid_t mUID;
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700364 sp<ANativeWindow> mConnectedWindow;
365 sp<IBinder> mConnectedWindowBinder;
John Grossmanc795b642012-02-22 15:38:35 -0800366 struct sockaddr_in mRetransmitEndpoint;
367 bool mRetransmitEndpointValid;
Marco Nelissen6b74d672012-02-28 16:07:44 -0800368 sp<Client> mNextClient;
Nicolas Catania48290382009-07-10 13:53:06 -0700369
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700370 // Metadata filters.
nikoa64c8c72009-07-20 15:07:26 -0700371 media::Metadata::Filter mMetadataAllow; // protected by mLock
372 media::Metadata::Filter mMetadataDrop; // protected by mLock
Nicolas Catania48290382009-07-10 13:53:06 -0700373
374 // Metadata updated. For each MEDIA_INFO_METADATA_UPDATE
375 // notification we try to update mMetadataUpdated which is a
376 // set: no duplicate.
377 // getMetadata clears this set.
nikoa64c8c72009-07-20 15:07:26 -0700378 media::Metadata::Filter mMetadataUpdated; // protected by mLock
Nicolas Catania48290382009-07-10 13:53:06 -0700379
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800380#if CALLBACK_ANTAGONIZER
381 Antagonizer* mAntagonizer;
382#endif
Marco Nelissen6b74d672012-02-28 16:07:44 -0800383 }; // Client
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800384
385// ----------------------------------------------------------------------------
386
387 MediaPlayerService();
388 virtual ~MediaPlayerService();
389
390 mutable Mutex mLock;
391 SortedVector< wp<Client> > mClients;
Gloria Wangdac6a312009-10-29 15:46:37 -0700392 SortedVector< wp<MediaRecorderClient> > mMediaRecorderClients;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800393 int32_t mNextConnId;
Andreas Huber318ad9c2009-10-15 13:46:54 -0700394 sp<IOMX> mOMX;
Andreas Hubered3e3e02012-03-26 11:13:27 -0700395 sp<ICrypto> mCrypto;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800396};
397
398// ----------------------------------------------------------------------------
399
400}; // namespace android
401
402#endif // ANDROID_MEDIAPLAYERSERVICE_H