The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 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 | |
John Grossman | c795b64 | 2012-02-22 15:38:35 -0800 | [diff] [blame] | 21 | #include <arpa/inet.h> |
| 22 | |
Mathias Agopian | 273d098 | 2009-05-31 19:13:00 -0700 | [diff] [blame] | 23 | #include <utils/threads.h> |
Mathias Agopian | 273d098 | 2009-05-31 19:13:00 -0700 | [diff] [blame] | 24 | #include <utils/Errors.h> |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 25 | #include <utils/KeyedVector.h> |
Andreas Huber | 2db8455 | 2010-01-28 11:19:57 -0800 | [diff] [blame] | 26 | #include <utils/String8.h> |
Nicolas Catania | a7e0e8b | 2009-07-08 08:57:42 -0700 | [diff] [blame] | 27 | #include <utils/Vector.h> |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 28 | |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 29 | #include <media/MediaPlayerInterface.h> |
niko | a64c8c7 | 2009-07-20 15:07:26 -0700 | [diff] [blame] | 30 | #include <media/Metadata.h> |
Marco Nelissen | 6b74d67 | 2012-02-28 16:07:44 -0800 | [diff] [blame] | 31 | #include <media/stagefright/foundation/ABase.h> |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 32 | |
Pawin Vongmasa | 9c47c97 | 2017-02-08 04:09:38 -0800 | [diff] [blame] | 33 | #include <android/hardware/media/omx/1.0/IOmx.h> |
| 34 | |
Dima Zavin | 6476024 | 2011-05-11 14:15:23 -0700 | [diff] [blame] | 35 | #include <system/audio.h> |
Dima Zavin | fce7a47 | 2011-04-19 22:30:36 -0700 | [diff] [blame] | 36 | |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 37 | namespace android { |
| 38 | |
Lajos Molnar | 3a474aa | 2015-04-24 17:10:07 -0700 | [diff] [blame] | 39 | struct AudioPlaybackRate; |
Glenn Kasten | a3f1fa3 | 2012-01-18 14:54:46 -0800 | [diff] [blame] | 40 | class AudioTrack; |
Lajos Molnar | 3a474aa | 2015-04-24 17:10:07 -0700 | [diff] [blame] | 41 | struct AVSyncSettings; |
Chris Watkins | 99f3160 | 2015-03-20 13:06:33 -0700 | [diff] [blame] | 42 | class IDataSource; |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 43 | class IMediaRecorder; |
| 44 | class IMediaMetadataRetriever; |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 45 | class IOMX; |
Jeff Brown | 2013a54 | 2012-09-04 21:38:42 -0700 | [diff] [blame] | 46 | class IRemoteDisplay; |
| 47 | class IRemoteDisplayClient; |
Gloria Wang | dac6a31 | 2009-10-29 15:46:37 -0700 | [diff] [blame] | 48 | class MediaRecorderClient; |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 49 | |
| 50 | #define CALLBACK_ANTAGONIZER 0 |
| 51 | #if CALLBACK_ANTAGONIZER |
| 52 | class Antagonizer { |
| 53 | public: |
| 54 | Antagonizer(notify_callback_f cb, void* client); |
| 55 | void start() { mActive = true; } |
| 56 | void stop() { mActive = false; } |
| 57 | void kill(); |
| 58 | private: |
| 59 | static const int interval; |
| 60 | Antagonizer(); |
| 61 | static int callbackThread(void* cookie); |
| 62 | Mutex mLock; |
| 63 | Condition mCondition; |
| 64 | bool mExit; |
| 65 | bool mActive; |
| 66 | void* mClient; |
| 67 | notify_callback_f mCb; |
| 68 | }; |
| 69 | #endif |
| 70 | |
| 71 | class MediaPlayerService : public BnMediaPlayerService |
| 72 | { |
| 73 | class Client; |
Pawin Vongmasa | 9c47c97 | 2017-02-08 04:09:38 -0800 | [diff] [blame] | 74 | typedef ::android::hardware::media::omx::V1_0::IOmx IOmx; |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 75 | |
| 76 | class AudioOutput : public MediaPlayerBase::AudioSink |
| 77 | { |
Marco Nelissen | 6b74d67 | 2012-02-28 16:07:44 -0800 | [diff] [blame] | 78 | class CallbackData; |
| 79 | |
| 80 | public: |
Andy Hung | 1afd098 | 2016-11-08 16:13:44 -0800 | [diff] [blame] | 81 | AudioOutput(audio_session_t sessionId, uid_t uid, int pid, |
Jean-Michel Trivi | d9d7fa0 | 2014-06-24 08:01:46 -0700 | [diff] [blame] | 82 | const audio_attributes_t * attr); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 83 | virtual ~AudioOutput(); |
| 84 | |
Glenn Kasten | 2799d74 | 2013-05-30 14:33:29 -0700 | [diff] [blame] | 85 | virtual bool ready() const { return mTrack != 0; } |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 86 | virtual ssize_t bufferSize() const; |
| 87 | virtual ssize_t frameCount() const; |
| 88 | virtual ssize_t channelCount() const; |
| 89 | virtual ssize_t frameSize() const; |
| 90 | virtual uint32_t latency() const; |
| 91 | virtual float msecsPerFrame() const; |
Marco Nelissen | 4110c10 | 2012-03-29 09:31:28 -0700 | [diff] [blame] | 92 | virtual status_t getPosition(uint32_t *position) const; |
Lajos Molnar | 06ad152 | 2014-08-28 07:27:44 -0700 | [diff] [blame] | 93 | virtual status_t getTimestamp(AudioTimestamp &ts) const; |
Wei Jia | c4ac817 | 2015-10-21 10:35:48 -0700 | [diff] [blame] | 94 | virtual int64_t getPlayedOutDurationUs(int64_t nowUs) const; |
Marco Nelissen | 4110c10 | 2012-03-29 09:31:28 -0700 | [diff] [blame] | 95 | virtual status_t getFramesWritten(uint32_t *frameswritten) const; |
Glenn Kasten | d848eb4 | 2016-03-08 13:42:11 -0800 | [diff] [blame] | 96 | virtual audio_session_t getSessionId() const; |
Eric Laurent | 6f59db1 | 2013-07-26 17:16:50 -0700 | [diff] [blame] | 97 | virtual uint32_t getSampleRate() const; |
Andy Hung | f2c87b3 | 2016-04-07 19:49:29 -0700 | [diff] [blame] | 98 | virtual int64_t getBufferDurationInUs() const; |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 99 | |
| 100 | virtual status_t open( |
Jean-Michel Trivi | 786618f | 2012-03-02 14:54:07 -0800 | [diff] [blame] | 101 | uint32_t sampleRate, int channelCount, audio_channel_mask_t channelMask, |
Glenn Kasten | e1c3962 | 2012-01-04 09:36:37 -0800 | [diff] [blame] | 102 | audio_format_t format, int bufferCount, |
Eric Laurent | 1948eb3 | 2012-04-13 16:50:19 -0700 | [diff] [blame] | 103 | AudioCallback cb, void *cookie, |
Richard Fitzgerald | ad3af33 | 2013-03-25 16:54:37 +0000 | [diff] [blame] | 104 | audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE, |
Ronghua Wu | faeb0f2 | 2015-05-21 12:20:21 -0700 | [diff] [blame] | 105 | const audio_offload_info_t *offloadInfo = NULL, |
Andy Hung | 179652e | 2015-05-31 22:49:46 -0700 | [diff] [blame] | 106 | bool doNotReconnect = false, |
| 107 | uint32_t suggestedFrameCount = 0); |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 108 | |
Richard Fitzgerald | d89532e | 2013-05-14 13:18:21 +0100 | [diff] [blame] | 109 | virtual status_t start(); |
Wei Jia | 7d3f4df | 2015-03-03 15:28:00 -0800 | [diff] [blame] | 110 | virtual ssize_t write(const void* buffer, size_t size, bool blocking = true); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 111 | virtual void stop(); |
| 112 | virtual void flush(); |
| 113 | virtual void pause(); |
| 114 | virtual void close(); |
Eric Laurent | 4356269 | 2015-07-15 16:49:07 -0700 | [diff] [blame] | 115 | void setAudioStreamType(audio_stream_type_t streamType); |
Eric Laurent | 2261234 | 2013-11-14 17:28:47 -0800 | [diff] [blame] | 116 | virtual audio_stream_type_t getAudioStreamType() const { return mStreamType; } |
Jean-Michel Trivi | d9d7fa0 | 2014-06-24 08:01:46 -0700 | [diff] [blame] | 117 | void setAudioAttributes(const audio_attributes_t * attributes); |
Eric Laurent | 2261234 | 2013-11-14 17:28:47 -0800 | [diff] [blame] | 118 | |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 119 | void setVolume(float left, float right); |
Lajos Molnar | 3a474aa | 2015-04-24 17:10:07 -0700 | [diff] [blame] | 120 | virtual status_t setPlaybackRate(const AudioPlaybackRate& rate); |
| 121 | virtual status_t getPlaybackRate(AudioPlaybackRate* rate /* nonnull */); |
| 122 | |
Eric Laurent | 2beeb50 | 2010-07-16 07:43:46 -0700 | [diff] [blame] | 123 | status_t setAuxEffectSendLevel(float level); |
| 124 | status_t attachAuxEffect(int effectId); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 125 | virtual status_t dump(int fd, const Vector<String16>& args) const; |
| 126 | |
| 127 | static bool isOnEmulator(); |
| 128 | static int getMinBufferCount(); |
Marco Nelissen | 6b74d67 | 2012-02-28 16:07:44 -0800 | [diff] [blame] | 129 | void setNextOutput(const sp<AudioOutput>& nextOutput); |
| 130 | void switchToNextOutput(); |
| 131 | virtual bool needsTrailingPadding() { return mNextOutput == NULL; } |
Richard Fitzgerald | d89532e | 2013-05-14 13:18:21 +0100 | [diff] [blame] | 132 | virtual status_t setParameters(const String8& keyValuePairs); |
| 133 | virtual String8 getParameters(const String8& keys); |
Marco Nelissen | 6b74d67 | 2012-02-28 16:07:44 -0800 | [diff] [blame] | 134 | |
Ivan Lozano | 8cf3a07 | 2017-08-09 09:01:33 -0700 | [diff] [blame^] | 135 | virtual media::VolumeShaper::Status applyVolumeShaper( |
| 136 | const sp<media::VolumeShaper::Configuration>& configuration, |
| 137 | const sp<media::VolumeShaper::Operation>& operation) override; |
| 138 | virtual sp<media::VolumeShaper::State> getVolumeShaperState(int id) override; |
Andy Hung | 9fc8b5c | 2017-01-24 13:36:48 -0800 | [diff] [blame] | 139 | |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 140 | private: |
| 141 | static void setMinBufferCount(); |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 142 | static void CallbackWrapper( |
Glenn Kasten | d217a8c | 2011-06-01 15:20:35 -0700 | [diff] [blame] | 143 | int event, void *me, void *info); |
Andy Hung | d1c7434 | 2015-07-07 16:54:23 -0700 | [diff] [blame] | 144 | void deleteRecycledTrack_l(); |
| 145 | void close_l(); |
Wei Jia | e0bbac9 | 2016-07-18 16:04:53 -0700 | [diff] [blame] | 146 | status_t updateTrack(); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 147 | |
Glenn Kasten | 2799d74 | 2013-05-30 14:33:29 -0700 | [diff] [blame] | 148 | sp<AudioTrack> mTrack; |
| 149 | sp<AudioTrack> mRecycledTrack; |
Marco Nelissen | 6b74d67 | 2012-02-28 16:07:44 -0800 | [diff] [blame] | 150 | sp<AudioOutput> mNextOutput; |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 151 | AudioCallback mCallback; |
| 152 | void * mCallbackCookie; |
Marco Nelissen | 6b74d67 | 2012-02-28 16:07:44 -0800 | [diff] [blame] | 153 | CallbackData * mCallbackData; |
Glenn Kasten | fff6d71 | 2012-01-12 16:38:12 -0800 | [diff] [blame] | 154 | audio_stream_type_t mStreamType; |
Jean-Michel Trivi | 2650e96 | 2015-07-22 18:14:02 -0700 | [diff] [blame] | 155 | audio_attributes_t * mAttributes; |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 156 | float mLeftVolume; |
| 157 | float mRightVolume; |
Lajos Molnar | 3a474aa | 2015-04-24 17:10:07 -0700 | [diff] [blame] | 158 | AudioPlaybackRate mPlaybackRate; |
Jean-Michel Trivi | 7a8b0ed | 2012-02-02 09:06:31 -0800 | [diff] [blame] | 159 | uint32_t mSampleRateHz; // sample rate of the content, as set in open() |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 160 | float mMsecsPerFrame; |
Andy Hung | d1c7434 | 2015-07-07 16:54:23 -0700 | [diff] [blame] | 161 | size_t mFrameSize; |
Glenn Kasten | d848eb4 | 2016-03-08 13:42:11 -0800 | [diff] [blame] | 162 | audio_session_t mSessionId; |
Andy Hung | 1afd098 | 2016-11-08 16:13:44 -0800 | [diff] [blame] | 163 | uid_t mUid; |
Marco Nelissen | d457c97 | 2014-02-11 08:47:07 -0800 | [diff] [blame] | 164 | int mPid; |
Eric Laurent | 2beeb50 | 2010-07-16 07:43:46 -0700 | [diff] [blame] | 165 | float mSendLevel; |
| 166 | int mAuxEffectId; |
Andy Hung | d1c7434 | 2015-07-07 16:54:23 -0700 | [diff] [blame] | 167 | audio_output_flags_t mFlags; |
Ivan Lozano | 8cf3a07 | 2017-08-09 09:01:33 -0700 | [diff] [blame^] | 168 | sp<media::VolumeHandler> mVolumeHandler; |
Andy Hung | d1c7434 | 2015-07-07 16:54:23 -0700 | [diff] [blame] | 169 | mutable Mutex mLock; |
| 170 | |
| 171 | // static variables below not protected by mutex |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 172 | static bool mIsOnEmulator; |
| 173 | static int mMinBufferCount; // 12 for emulator; otherwise 4 |
| 174 | |
Marco Nelissen | 6b74d67 | 2012-02-28 16:07:44 -0800 | [diff] [blame] | 175 | // CallbackData is what is passed to the AudioTrack as the "user" data. |
| 176 | // We need to be able to target this to a different Output on the fly, |
| 177 | // so we can't use the Output itself for this. |
| 178 | class CallbackData { |
Andy Hung | d1c7434 | 2015-07-07 16:54:23 -0700 | [diff] [blame] | 179 | friend AudioOutput; |
Marco Nelissen | 6b74d67 | 2012-02-28 16:07:44 -0800 | [diff] [blame] | 180 | public: |
Chih-Hung Hsieh | 36d0ca1 | 2016-08-09 14:31:32 -0700 | [diff] [blame] | 181 | explicit CallbackData(AudioOutput *cookie) { |
Marco Nelissen | 6b74d67 | 2012-02-28 16:07:44 -0800 | [diff] [blame] | 182 | mData = cookie; |
| 183 | mSwitching = false; |
| 184 | } |
Andy Hung | d1c7434 | 2015-07-07 16:54:23 -0700 | [diff] [blame] | 185 | AudioOutput * getOutput() const { return mData; } |
Marco Nelissen | 6b74d67 | 2012-02-28 16:07:44 -0800 | [diff] [blame] | 186 | void setOutput(AudioOutput* newcookie) { mData = newcookie; } |
| 187 | // lock/unlock are used by the callback before accessing the payload of this object |
Andy Hung | d1c7434 | 2015-07-07 16:54:23 -0700 | [diff] [blame] | 188 | void lock() const { mLock.lock(); } |
| 189 | void unlock() const { mLock.unlock(); } |
| 190 | |
| 191 | // tryBeginTrackSwitch/endTrackSwitch are used when the CallbackData is handed over |
Marco Nelissen | 6b74d67 | 2012-02-28 16:07:44 -0800 | [diff] [blame] | 192 | // to the next sink. |
Andy Hung | d1c7434 | 2015-07-07 16:54:23 -0700 | [diff] [blame] | 193 | |
| 194 | // tryBeginTrackSwitch() returns true only if it obtains the lock. |
| 195 | bool tryBeginTrackSwitch() { |
| 196 | LOG_ALWAYS_FATAL_IF(mSwitching, "tryBeginTrackSwitch() already called"); |
| 197 | if (mLock.tryLock() != OK) { |
| 198 | return false; |
| 199 | } |
| 200 | mSwitching = true; |
| 201 | return true; |
| 202 | } |
Marco Nelissen | 6b74d67 | 2012-02-28 16:07:44 -0800 | [diff] [blame] | 203 | void endTrackSwitch() { |
| 204 | if (mSwitching) { |
| 205 | mLock.unlock(); |
| 206 | } |
| 207 | mSwitching = false; |
| 208 | } |
| 209 | private: |
| 210 | AudioOutput * mData; |
Andy Hung | d1c7434 | 2015-07-07 16:54:23 -0700 | [diff] [blame] | 211 | mutable Mutex mLock; // a recursive mutex might make this unnecessary. |
Marco Nelissen | 6b74d67 | 2012-02-28 16:07:44 -0800 | [diff] [blame] | 212 | bool mSwitching; |
| 213 | DISALLOW_EVIL_CONSTRUCTORS(CallbackData); |
| 214 | }; |
| 215 | |
| 216 | }; // AudioOutput |
| 217 | |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 218 | |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 219 | public: |
| 220 | static void instantiate(); |
| 221 | |
| 222 | // IMediaPlayerService interface |
Svet Ganov | be71aa2 | 2015-04-28 12:06:02 -0700 | [diff] [blame] | 223 | virtual sp<IMediaRecorder> createMediaRecorder(const String16 &opPackageName); |
Chih-Hung Hsieh | 36d0ca1 | 2016-08-09 14:31:32 -0700 | [diff] [blame] | 224 | void removeMediaRecorderClient(const wp<MediaRecorderClient>& client); |
Glenn Kasten | f37971f | 2012-02-03 11:06:53 -0800 | [diff] [blame] | 225 | virtual sp<IMediaMetadataRetriever> createMetadataRetriever(); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 226 | |
Glenn Kasten | d848eb4 | 2016-03-08 13:42:11 -0800 | [diff] [blame] | 227 | virtual sp<IMediaPlayer> create(const sp<IMediaPlayerClient>& client, |
| 228 | audio_session_t audioSessionId); |
Andreas Huber | e2b1028 | 2010-11-23 11:41:34 -0800 | [diff] [blame] | 229 | |
Lajos Molnar | 1381d4b | 2014-08-07 15:18:35 -0700 | [diff] [blame] | 230 | virtual sp<IMediaCodecList> getCodecList() const; |
Marco Nelissen | 260e56c | 2016-01-28 21:41:25 +0000 | [diff] [blame] | 231 | virtual sp<IOMX> getOMX(); |
Andreas Huber | 279dcd8 | 2013-01-30 10:41:25 -0800 | [diff] [blame] | 232 | virtual sp<IHDCP> makeHDCP(bool createEncryptionModule); |
Jeff Brown | 2013a54 | 2012-09-04 21:38:42 -0700 | [diff] [blame] | 233 | |
Svet Ganov | be71aa2 | 2015-04-28 12:06:02 -0700 | [diff] [blame] | 234 | virtual sp<IRemoteDisplay> listenForRemoteDisplay(const String16 &opPackageName, |
| 235 | const sp<IRemoteDisplayClient>& client, const String8& iface); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 236 | virtual status_t dump(int fd, const Vector<String16>& args); |
| 237 | |
Chih-Hung Hsieh | 36d0ca1 | 2016-08-09 14:31:32 -0700 | [diff] [blame] | 238 | void removeClient(const wp<Client>& client); |
Robert Shih | ee0a0e3 | 2016-08-16 16:50:54 -0700 | [diff] [blame] | 239 | bool hasClient(wp<Client> client); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 240 | |
Marco Nelissen | 6dc3a3e | 2016-04-29 15:42:06 -0700 | [diff] [blame] | 241 | enum { |
| 242 | MEDIASERVER_PROCESS_DEATH = 0, |
| 243 | MEDIAEXTRACTOR_PROCESS_DEATH = 1, |
| 244 | MEDIACODEC_PROCESS_DEATH = 2, |
Andy Hung | 0bfa3ee | 2016-05-13 15:48:36 -0700 | [diff] [blame] | 245 | AUDIO_PROCESS_DEATH = 3, // currently no need to track this |
Marco Nelissen | 6dc3a3e | 2016-04-29 15:42:06 -0700 | [diff] [blame] | 246 | CAMERA_PROCESS_DEATH = 4 |
| 247 | }; |
| 248 | |
Gloria Wang | 7cf180c | 2011-02-19 18:37:57 -0800 | [diff] [blame] | 249 | // Collect info of the codec usage from media player and media recorder |
| 250 | virtual void addBatteryData(uint32_t params); |
| 251 | // API for the Battery app to pull the data of codecs usage |
| 252 | virtual status_t pullBatteryData(Parcel* reply); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 253 | private: |
Chong Zhang | e5b9b69 | 2017-05-11 11:44:56 -0700 | [diff] [blame] | 254 | struct BatteryTracker { |
| 255 | BatteryTracker(); |
| 256 | // Collect info of the codec usage from media player and media recorder |
| 257 | void addBatteryData(uint32_t params); |
| 258 | // API for the Battery app to pull the data of codecs usage |
| 259 | status_t pullBatteryData(Parcel* reply); |
| 260 | |
| 261 | private: |
| 262 | // For battery usage tracking purpose |
| 263 | struct BatteryUsageInfo { |
| 264 | // how many streams are being played by one UID |
| 265 | int refCount; |
| 266 | // a temp variable to store the duration(ms) of audio codecs |
| 267 | // when we start a audio codec, we minus the system time from audioLastTime |
| 268 | // when we pause it, we add the system time back to the audioLastTime |
| 269 | // so after the pause, audioLastTime = pause time - start time |
| 270 | // if multiple audio streams are played (or recorded), then audioLastTime |
| 271 | // = the total playing time of all the streams |
| 272 | int32_t audioLastTime; |
| 273 | // when all the audio streams are being paused, we assign audioLastTime to |
| 274 | // this variable, so this value could be provided to the battery app |
| 275 | // in the next pullBatteryData call |
| 276 | int32_t audioTotalTime; |
| 277 | |
| 278 | int32_t videoLastTime; |
| 279 | int32_t videoTotalTime; |
| 280 | }; |
| 281 | KeyedVector<int, BatteryUsageInfo> mBatteryData; |
| 282 | |
| 283 | enum { |
| 284 | SPEAKER, |
| 285 | OTHER_AUDIO_DEVICE, |
| 286 | SPEAKER_AND_OTHER, |
| 287 | NUM_AUDIO_DEVICES |
| 288 | }; |
| 289 | |
| 290 | struct BatteryAudioFlingerUsageInfo { |
| 291 | int refCount; // how many audio streams are being played |
| 292 | int deviceOn[NUM_AUDIO_DEVICES]; // whether the device is currently used |
| 293 | int32_t lastTime[NUM_AUDIO_DEVICES]; // in ms |
| 294 | // totalTime[]: total time of audio output devices usage |
| 295 | int32_t totalTime[NUM_AUDIO_DEVICES]; // in ms |
| 296 | }; |
| 297 | |
| 298 | // This varialble is used to record the usage of audio output device |
| 299 | // for battery app |
| 300 | BatteryAudioFlingerUsageInfo mBatteryAudio; |
| 301 | |
| 302 | mutable Mutex mLock; |
| 303 | }; |
| 304 | BatteryTracker mBatteryTracker; |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 305 | |
| 306 | class Client : public BnMediaPlayer { |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 307 | // IMediaPlayer interface |
| 308 | virtual void disconnect(); |
Glenn Kasten | 1173118 | 2011-02-08 17:26:17 -0800 | [diff] [blame] | 309 | virtual status_t setVideoSurfaceTexture( |
Andy McFadden | 484566c | 2012-12-18 09:46:54 -0800 | [diff] [blame] | 310 | const sp<IGraphicBufferProducer>& bufferProducer); |
Wei Jia | d399e7e | 2016-10-26 15:49:11 -0700 | [diff] [blame] | 311 | virtual status_t setBufferingSettings(const BufferingSettings& buffering) override; |
| 312 | virtual status_t getDefaultBufferingSettings( |
| 313 | BufferingSettings* buffering /* nonnull */) override; |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 314 | virtual status_t prepareAsync(); |
| 315 | virtual status_t start(); |
| 316 | virtual status_t stop(); |
| 317 | virtual status_t pause(); |
| 318 | virtual status_t isPlaying(bool* state); |
Lajos Molnar | 3a474aa | 2015-04-24 17:10:07 -0700 | [diff] [blame] | 319 | virtual status_t setPlaybackSettings(const AudioPlaybackRate& rate); |
| 320 | virtual status_t getPlaybackSettings(AudioPlaybackRate* rate /* nonnull */); |
| 321 | virtual status_t setSyncSettings(const AVSyncSettings& rate, float videoFpsHint); |
| 322 | virtual status_t getSyncSettings(AVSyncSettings* rate /* nonnull */, |
| 323 | float* videoFps /* nonnull */); |
Wei Jia | c5de091 | 2016-11-18 10:22:14 -0800 | [diff] [blame] | 324 | virtual status_t seekTo( |
| 325 | int msec, |
| 326 | MediaPlayerSeekMode mode = MediaPlayerSeekMode::SEEK_PREVIOUS_SYNC); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 327 | virtual status_t getCurrentPosition(int* msec); |
| 328 | virtual status_t getDuration(int* msec); |
| 329 | virtual status_t reset(); |
Glenn Kasten | fff6d71 | 2012-01-12 16:38:12 -0800 | [diff] [blame] | 330 | virtual status_t setAudioStreamType(audio_stream_type_t type); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 331 | virtual status_t setLooping(int loop); |
| 332 | virtual status_t setVolume(float leftVolume, float rightVolume); |
Nicolas Catania | 1d187f1 | 2009-05-12 23:25:55 -0700 | [diff] [blame] | 333 | virtual status_t invoke(const Parcel& request, Parcel *reply); |
Nicolas Catania | a7e0e8b | 2009-07-08 08:57:42 -0700 | [diff] [blame] | 334 | virtual status_t setMetadataFilter(const Parcel& filter); |
Nicolas Catania | 4829038 | 2009-07-10 13:53:06 -0700 | [diff] [blame] | 335 | virtual status_t getMetadata(bool update_only, |
| 336 | bool apply_filter, |
| 337 | Parcel *reply); |
Eric Laurent | 2beeb50 | 2010-07-16 07:43:46 -0700 | [diff] [blame] | 338 | virtual status_t setAuxEffectSendLevel(float level); |
| 339 | virtual status_t attachAuxEffect(int effectId); |
Gloria Wang | 4f9e47f | 2011-04-25 17:28:22 -0700 | [diff] [blame] | 340 | virtual status_t setParameter(int key, const Parcel &request); |
| 341 | virtual status_t getParameter(int key, Parcel *reply); |
John Grossman | c795b64 | 2012-02-22 15:38:35 -0800 | [diff] [blame] | 342 | virtual status_t setRetransmitEndpoint(const struct sockaddr_in* endpoint); |
John Grossman | 44a7e42 | 2012-06-21 17:29:24 -0700 | [diff] [blame] | 343 | virtual status_t getRetransmitEndpoint(struct sockaddr_in* endpoint); |
Marco Nelissen | 6b74d67 | 2012-02-28 16:07:44 -0800 | [diff] [blame] | 344 | virtual status_t setNextPlayer(const sp<IMediaPlayer>& player); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 345 | |
Ivan Lozano | 8cf3a07 | 2017-08-09 09:01:33 -0700 | [diff] [blame^] | 346 | virtual media::VolumeShaper::Status applyVolumeShaper( |
| 347 | const sp<media::VolumeShaper::Configuration>& configuration, |
| 348 | const sp<media::VolumeShaper::Operation>& operation) override; |
| 349 | virtual sp<media::VolumeShaper::State> getVolumeShaperState(int id) override; |
Andy Hung | 9fc8b5c | 2017-01-24 13:36:48 -0800 | [diff] [blame] | 350 | |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 351 | sp<MediaPlayerBase> createPlayer(player_type playerType); |
Andreas Huber | 2db8455 | 2010-01-28 11:19:57 -0800 | [diff] [blame] | 352 | |
Dave Burke | d681bbb | 2011-08-30 14:39:17 +0100 | [diff] [blame] | 353 | virtual status_t setDataSource( |
Andreas Huber | 1b86fe0 | 2014-01-29 11:13:26 -0800 | [diff] [blame] | 354 | const sp<IMediaHTTPService> &httpService, |
Andreas Huber | 2db8455 | 2010-01-28 11:19:57 -0800 | [diff] [blame] | 355 | const char *url, |
| 356 | const KeyedVector<String8, String8> *headers); |
| 357 | |
Dave Burke | d681bbb | 2011-08-30 14:39:17 +0100 | [diff] [blame] | 358 | virtual status_t setDataSource(int fd, int64_t offset, int64_t length); |
Andreas Huber | e2b1028 | 2010-11-23 11:41:34 -0800 | [diff] [blame] | 359 | |
Dave Burke | d681bbb | 2011-08-30 14:39:17 +0100 | [diff] [blame] | 360 | virtual status_t setDataSource(const sp<IStreamSource> &source); |
Chris Watkins | 99f3160 | 2015-03-20 13:06:33 -0700 | [diff] [blame] | 361 | virtual status_t setDataSource(const sp<IDataSource> &source); |
| 362 | |
Andreas Huber | e2b1028 | 2010-11-23 11:41:34 -0800 | [diff] [blame] | 363 | |
John Grossman | c795b64 | 2012-02-22 15:38:35 -0800 | [diff] [blame] | 364 | sp<MediaPlayerBase> setDataSource_pre(player_type playerType); |
| 365 | void setDataSource_post(const sp<MediaPlayerBase>& p, |
| 366 | status_t status); |
| 367 | |
Gloria Wang | b483c47 | 2011-04-11 17:23:27 -0700 | [diff] [blame] | 368 | static void notify(void* cookie, int msg, |
| 369 | int ext1, int ext2, const Parcel *obj); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 370 | |
| 371 | pid_t pid() const { return mPid; } |
Lajos Molnar | 6d339f1 | 2015-04-17 16:15:53 -0700 | [diff] [blame] | 372 | virtual status_t dump(int fd, const Vector<String16>& args); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 373 | |
Glenn Kasten | d848eb4 | 2016-03-08 13:42:11 -0800 | [diff] [blame] | 374 | audio_session_t getAudioSessionId() { return mAudioSessionId; } |
Hassan Shojania | cefac14 | 2017-02-06 21:02:02 -0800 | [diff] [blame] | 375 | // Modular DRM |
| 376 | virtual status_t prepareDrm(const uint8_t uuid[16], const Vector<uint8_t>& drmSessionId); |
| 377 | virtual status_t releaseDrm(); |
Eric Laurent | a514bdb | 2010-06-21 09:27:30 -0700 | [diff] [blame] | 378 | |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 379 | private: |
Pawin Vongmasa | 9c47c97 | 2017-02-08 04:09:38 -0800 | [diff] [blame] | 380 | class ServiceDeathNotifier: |
| 381 | public IBinder::DeathRecipient, |
| 382 | public ::android::hardware::hidl_death_recipient |
Marco Nelissen | 6dc3a3e | 2016-04-29 15:42:06 -0700 | [diff] [blame] | 383 | { |
| 384 | public: |
| 385 | ServiceDeathNotifier( |
| 386 | const sp<IBinder>& service, |
| 387 | const sp<MediaPlayerBase>& listener, |
| 388 | int which); |
Pawin Vongmasa | 9c47c97 | 2017-02-08 04:09:38 -0800 | [diff] [blame] | 389 | ServiceDeathNotifier( |
| 390 | const sp<IOmx>& omx, |
| 391 | const sp<MediaPlayerBase>& listener, |
| 392 | int which); |
Marco Nelissen | 6dc3a3e | 2016-04-29 15:42:06 -0700 | [diff] [blame] | 393 | virtual ~ServiceDeathNotifier(); |
| 394 | virtual void binderDied(const wp<IBinder>& who); |
Pawin Vongmasa | 9c47c97 | 2017-02-08 04:09:38 -0800 | [diff] [blame] | 395 | virtual void serviceDied( |
| 396 | uint64_t cookie, |
| 397 | const wp<::android::hidl::base::V1_0::IBase>& who); |
| 398 | void unlinkToDeath(); |
Marco Nelissen | 6dc3a3e | 2016-04-29 15:42:06 -0700 | [diff] [blame] | 399 | |
| 400 | private: |
| 401 | int mWhich; |
| 402 | sp<IBinder> mService; |
Pawin Vongmasa | 9c47c97 | 2017-02-08 04:09:38 -0800 | [diff] [blame] | 403 | sp<IOmx> mOmx; |
Marco Nelissen | 6dc3a3e | 2016-04-29 15:42:06 -0700 | [diff] [blame] | 404 | wp<MediaPlayerBase> mListener; |
| 405 | }; |
| 406 | |
Pawin Vongmasa | 9c47c97 | 2017-02-08 04:09:38 -0800 | [diff] [blame] | 407 | void clearDeathNotifiers(); |
| 408 | |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 409 | friend class MediaPlayerService; |
| 410 | Client( const sp<MediaPlayerService>& service, |
| 411 | pid_t pid, |
| 412 | int32_t connId, |
Eric Laurent | a514bdb | 2010-06-21 09:27:30 -0700 | [diff] [blame] | 413 | const sp<IMediaPlayerClient>& client, |
Glenn Kasten | d848eb4 | 2016-03-08 13:42:11 -0800 | [diff] [blame] | 414 | audio_session_t audioSessionId, |
Andreas Huber | 9b80c2b | 2011-06-30 15:47:02 -0700 | [diff] [blame] | 415 | uid_t uid); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 416 | Client(); |
| 417 | virtual ~Client(); |
| 418 | |
| 419 | void deletePlayer(); |
| 420 | |
| 421 | sp<MediaPlayerBase> getPlayer() const { Mutex::Autolock lock(mLock); return mPlayer; } |
| 422 | |
Nicolas Catania | a7e0e8b | 2009-07-08 08:57:42 -0700 | [diff] [blame] | 423 | |
Nicolas Catania | 4829038 | 2009-07-10 13:53:06 -0700 | [diff] [blame] | 424 | |
| 425 | // @param type Of the metadata to be tested. |
| 426 | // @return true if the metadata should be dropped according to |
| 427 | // the filters. |
niko | a64c8c7 | 2009-07-20 15:07:26 -0700 | [diff] [blame] | 428 | bool shouldDropMetadata(media::Metadata::Type type) const; |
Nicolas Catania | 4829038 | 2009-07-10 13:53:06 -0700 | [diff] [blame] | 429 | |
| 430 | // Add a new element to the set of metadata updated. Noop if |
| 431 | // the element exists already. |
| 432 | // @param type Of the metadata to be recorded. |
niko | a64c8c7 | 2009-07-20 15:07:26 -0700 | [diff] [blame] | 433 | void addNewMetadataUpdate(media::Metadata::Type type); |
Nicolas Catania | a7e0e8b | 2009-07-08 08:57:42 -0700 | [diff] [blame] | 434 | |
Jamie Gennis | 7dae00b | 2011-10-26 18:36:31 -0700 | [diff] [blame] | 435 | // Disconnect from the currently connected ANativeWindow. |
| 436 | void disconnectNativeWindow(); |
| 437 | |
Jean-Michel Trivi | d9d7fa0 | 2014-06-24 08:01:46 -0700 | [diff] [blame] | 438 | status_t setAudioAttributes_l(const Parcel &request); |
| 439 | |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 440 | mutable Mutex mLock; |
| 441 | sp<MediaPlayerBase> mPlayer; |
| 442 | sp<MediaPlayerService> mService; |
| 443 | sp<IMediaPlayerClient> mClient; |
| 444 | sp<AudioOutput> mAudioOutput; |
| 445 | pid_t mPid; |
| 446 | status_t mStatus; |
| 447 | bool mLoop; |
| 448 | int32_t mConnId; |
Glenn Kasten | d848eb4 | 2016-03-08 13:42:11 -0800 | [diff] [blame] | 449 | audio_session_t mAudioSessionId; |
Jean-Michel Trivi | d9d7fa0 | 2014-06-24 08:01:46 -0700 | [diff] [blame] | 450 | audio_attributes_t * mAudioAttributes; |
Andy Hung | 1afd098 | 2016-11-08 16:13:44 -0800 | [diff] [blame] | 451 | uid_t mUid; |
Jamie Gennis | 7dae00b | 2011-10-26 18:36:31 -0700 | [diff] [blame] | 452 | sp<ANativeWindow> mConnectedWindow; |
| 453 | sp<IBinder> mConnectedWindowBinder; |
John Grossman | c795b64 | 2012-02-22 15:38:35 -0800 | [diff] [blame] | 454 | struct sockaddr_in mRetransmitEndpoint; |
| 455 | bool mRetransmitEndpointValid; |
Marco Nelissen | 6b74d67 | 2012-02-28 16:07:44 -0800 | [diff] [blame] | 456 | sp<Client> mNextClient; |
Nicolas Catania | 4829038 | 2009-07-10 13:53:06 -0700 | [diff] [blame] | 457 | |
Nicolas Catania | a7e0e8b | 2009-07-08 08:57:42 -0700 | [diff] [blame] | 458 | // Metadata filters. |
niko | a64c8c7 | 2009-07-20 15:07:26 -0700 | [diff] [blame] | 459 | media::Metadata::Filter mMetadataAllow; // protected by mLock |
| 460 | media::Metadata::Filter mMetadataDrop; // protected by mLock |
Nicolas Catania | 4829038 | 2009-07-10 13:53:06 -0700 | [diff] [blame] | 461 | |
| 462 | // Metadata updated. For each MEDIA_INFO_METADATA_UPDATE |
| 463 | // notification we try to update mMetadataUpdated which is a |
| 464 | // set: no duplicate. |
| 465 | // getMetadata clears this set. |
niko | a64c8c7 | 2009-07-20 15:07:26 -0700 | [diff] [blame] | 466 | media::Metadata::Filter mMetadataUpdated; // protected by mLock |
Nicolas Catania | 4829038 | 2009-07-10 13:53:06 -0700 | [diff] [blame] | 467 | |
Pawin Vongmasa | 9c47c97 | 2017-02-08 04:09:38 -0800 | [diff] [blame] | 468 | sp<ServiceDeathNotifier> mExtractorDeathListener; |
| 469 | sp<ServiceDeathNotifier> mCodecDeathListener; |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 470 | #if CALLBACK_ANTAGONIZER |
| 471 | Antagonizer* mAntagonizer; |
| 472 | #endif |
Marco Nelissen | 6b74d67 | 2012-02-28 16:07:44 -0800 | [diff] [blame] | 473 | }; // Client |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 474 | |
| 475 | // ---------------------------------------------------------------------------- |
| 476 | |
| 477 | MediaPlayerService(); |
| 478 | virtual ~MediaPlayerService(); |
| 479 | |
| 480 | mutable Mutex mLock; |
| 481 | SortedVector< wp<Client> > mClients; |
Gloria Wang | dac6a31 | 2009-10-29 15:46:37 -0700 | [diff] [blame] | 482 | SortedVector< wp<MediaRecorderClient> > mMediaRecorderClients; |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 483 | int32_t mNextConnId; |
Marco Nelissen | 260e56c | 2016-01-28 21:41:25 +0000 | [diff] [blame] | 484 | sp<IOMX> mOMX; |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 485 | }; |
| 486 | |
| 487 | // ---------------------------------------------------------------------------- |
| 488 | |
| 489 | }; // namespace android |
| 490 | |
| 491 | #endif // ANDROID_MEDIAPLAYERSERVICE_H |