1 /* 2 * Copyright 2017 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef NU_PLAYER2_H_ 18 19 #define NU_PLAYER2_H_ 20 21 #include <media/AudioResamplerPublic.h> 22 #include <media/stagefright/foundation/AHandler.h> 23 24 #include <mediaplayer2/MediaPlayer2Interface.h> 25 26 namespace android { 27 28 struct ABuffer; 29 struct AMediaCryptoWrapper; 30 struct AMessage; 31 struct ANativeWindowWrapper; 32 struct AudioPlaybackRate; 33 struct AVSyncSettings; 34 struct DataSourceDesc; 35 struct MediaClock; 36 struct MediaHTTPService; 37 class MetaData; 38 struct NuPlayer2Driver; 39 40 struct NuPlayer2 : public AHandler { 41 explicit NuPlayer2(pid_t pid, uid_t uid, const sp<MediaClock> &mediaClock); 42 43 void setDriver(const wp<NuPlayer2Driver> &driver); 44 45 void setDataSourceAsync(const sp<DataSourceDesc> &dsd); 46 void prepareNextDataSourceAsync(const sp<DataSourceDesc> &dsd); 47 void playNextDataSource(int64_t srcId); 48 49 status_t getBufferingSettings(BufferingSettings* buffering /* nonnull */); 50 status_t setBufferingSettings(const BufferingSettings& buffering); 51 52 void prepareAsync(); 53 54 void setVideoSurfaceTextureAsync(const sp<ANativeWindowWrapper> &nww); 55 56 void setAudioSink(const sp<MediaPlayer2Interface::AudioSink> &sink); 57 status_t setPlaybackSettings(const AudioPlaybackRate &rate); 58 status_t getPlaybackSettings(AudioPlaybackRate *rate /* nonnull */); 59 status_t setSyncSettings(const AVSyncSettings &sync, float videoFpsHint); 60 status_t getSyncSettings(AVSyncSettings *sync /* nonnull */, float *videoFps /* nonnull */); 61 62 void start(); 63 64 void pause(); 65 66 // Will notify the driver through "notifyResetComplete" once finished. 67 void resetAsync(); 68 69 // Request a notification when specified media time is reached. 70 status_t notifyAt(int64_t mediaTimeUs); 71 72 // Will notify the driver through "notifySeekComplete" once finished 73 // and needNotify is true. 74 void seekToAsync( 75 int64_t seekTimeUs, 76 MediaPlayer2SeekMode mode = MediaPlayer2SeekMode::SEEK_PREVIOUS_SYNC, 77 bool needNotify = false); 78 79 status_t setVideoScalingMode(int32_t mode); 80 status_t getTrackInfo(Parcel* reply) const; 81 status_t getSelectedTrack(int32_t type, Parcel* reply) const; 82 status_t selectTrack(size_t trackIndex, bool select, int64_t timeUs); 83 status_t getCurrentPosition(int64_t *mediaUs); 84 void getStats(Vector<sp<AMessage> > *mTrackStats); 85 86 sp<MetaData> getFileMeta(); 87 float getFrameRate(); 88 89 // Modular DRM 90 status_t prepareDrm(const uint8_t uuid[16], const Vector<uint8_t> &drmSessionId); 91 status_t releaseDrm(); 92 93 const char *getDataSourceType(); 94 95 protected: 96 virtual ~NuPlayer2(); 97 98 virtual void onMessageReceived(const sp<AMessage> &msg); 99 100 public: 101 struct StreamListener; 102 struct Source; 103 104 private: 105 struct Decoder; 106 struct DecoderBase; 107 struct DecoderPassThrough; 108 struct CCDecoder; 109 struct GenericSource2; 110 struct HTTPLiveSource2; 111 struct Renderer; 112 struct RTSPSource2; 113 struct Action; 114 struct SeekAction; 115 struct SetSurfaceAction; 116 struct ResumeDecoderAction; 117 struct FlushDecoderAction; 118 struct PostMessageAction; 119 struct SimpleAction; 120 121 enum { 122 kWhatSetDataSource = '=DaS', 123 kWhatPrepare = 'prep', 124 kWhatPrepareNextDataSource = 'pNDS', 125 kWhatPlayNextDataSource = 'plNS', 126 kWhatSetVideoSurface = '=VSu', 127 kWhatSetAudioSink = '=AuS', 128 kWhatMoreDataQueued = 'more', 129 kWhatConfigPlayback = 'cfPB', 130 kWhatConfigSync = 'cfSy', 131 kWhatGetPlaybackSettings = 'gPbS', 132 kWhatGetSyncSettings = 'gSyS', 133 kWhatStart = 'strt', 134 kWhatScanSources = 'scan', 135 kWhatVideoNotify = 'vidN', 136 kWhatAudioNotify = 'audN', 137 kWhatClosedCaptionNotify = 'capN', 138 kWhatRendererNotify = 'renN', 139 kWhatReset = 'rset', 140 kWhatNotifyTime = 'nfyT', 141 kWhatSeek = 'seek', 142 kWhatPause = 'paus', 143 kWhatResume = 'rsme', 144 kWhatPollDuration = 'polD', 145 kWhatSourceNotify = 'srcN', 146 kWhatGetTrackInfo = 'gTrI', 147 kWhatGetSelectedTrack = 'gSel', 148 kWhatSelectTrack = 'selT', 149 kWhatGetBufferingSettings = 'gBus', 150 kWhatSetBufferingSettings = 'sBuS', 151 kWhatPrepareDrm = 'pDrm', 152 kWhatReleaseDrm = 'rDrm', 153 }; 154 155 wp<NuPlayer2Driver> mDriver; 156 pid_t mPID; 157 uid_t mUID; 158 const sp<MediaClock> mMediaClock; 159 Mutex mSourceLock; // guard |mSource|. 160 sp<Source> mSource; 161 int64_t mSrcId; 162 uint32_t mSourceFlags; 163 sp<Source> mNextSource; 164 int64_t mNextSrcId; 165 uint32_t mNextSourceFlags; 166 sp<ANativeWindowWrapper> mNativeWindow; 167 sp<MediaPlayer2Interface::AudioSink> mAudioSink; 168 sp<DecoderBase> mVideoDecoder; 169 bool mOffloadAudio; 170 sp<DecoderBase> mAudioDecoder; 171 sp<CCDecoder> mCCDecoder; 172 sp<Renderer> mRenderer; 173 sp<ALooper> mRendererLooper; 174 int32_t mAudioDecoderGeneration; 175 int32_t mVideoDecoderGeneration; 176 int32_t mRendererGeneration; 177 178 Mutex mPlayingTimeLock; 179 int64_t mLastStartedPlayingTimeNs; 180 void stopPlaybackTimer(const char *where); 181 void startPlaybackTimer(const char *where); 182 183 int64_t mLastStartedRebufferingTimeNs; 184 void startRebufferingTimer(); 185 void stopRebufferingTimer(bool exitingPlayback); 186 187 int64_t mPreviousSeekTimeUs; 188 189 List<sp<Action> > mDeferredActions; 190 191 bool mAudioEOS; 192 bool mVideoEOS; 193 194 bool mScanSourcesPending; 195 int32_t mScanSourcesGeneration; 196 197 int32_t mPollDurationGeneration; 198 int32_t mTimedTextGeneration; 199 200 enum FlushStatus { 201 NONE, 202 FLUSHING_DECODER, 203 FLUSHING_DECODER_SHUTDOWN, 204 SHUTTING_DOWN_DECODER, 205 FLUSHED, 206 SHUT_DOWN, 207 }; 208 209 enum FlushCommand { 210 FLUSH_CMD_NONE, 211 FLUSH_CMD_FLUSH, 212 FLUSH_CMD_SHUTDOWN, 213 }; 214 215 // Status of flush responses from the decoder and renderer. 216 bool mFlushComplete[2][2]; 217 218 FlushStatus mFlushingAudio; 219 FlushStatus mFlushingVideo; 220 221 // Status of flush responses from the decoder and renderer. 222 bool mResumePending; 223 224 int32_t mVideoScalingMode; 225 226 AudioPlaybackRate mPlaybackSettings; 227 AVSyncSettings mSyncSettings; 228 float mVideoFpsHint; 229 bool mStarted; 230 bool mPrepared; 231 bool mResetting; 232 bool mSourceStarted; 233 bool mAudioDecoderError; 234 bool mVideoDecoderError; 235 236 // Actual pause state, either as requested by client or due to buffering. 237 bool mPaused; 238 239 // Pause state as requested by client. Note that if mPausedByClient is 240 // true, mPaused is always true; if mPausedByClient is false, mPaused could 241 // still become true, when we pause internally due to buffering. 242 bool mPausedByClient; 243 244 // Pause state as requested by source (internally) due to buffering 245 bool mPausedForBuffering; 246 247 // Modular DRM 248 sp<AMediaCryptoWrapper> mCrypto; 249 bool mIsDrmProtected; 250 251 typedef enum { 252 DATA_SOURCE_TYPE_NONE, 253 DATA_SOURCE_TYPE_HTTP_LIVE, 254 DATA_SOURCE_TYPE_RTSP, 255 DATA_SOURCE_TYPE_GENERIC_URL, 256 DATA_SOURCE_TYPE_GENERIC_FD, 257 DATA_SOURCE_TYPE_MEDIA, 258 } DATA_SOURCE_TYPE; 259 260 std::atomic<DATA_SOURCE_TYPE> mDataSourceType; 261 std::atomic<DATA_SOURCE_TYPE> mNextDataSourceType; 262 263 inline const sp<DecoderBase> &getDecoder(bool audio) { 264 return audio ? mAudioDecoder : mVideoDecoder; 265 } 266 267 inline void clearFlushComplete() { 268 mFlushComplete[0][0] = false; 269 mFlushComplete[0][1] = false; 270 mFlushComplete[1][0] = false; 271 mFlushComplete[1][1] = false; 272 } 273 274 void disconnectSource(); 275 276 status_t createNuPlayer2Source(const sp<DataSourceDesc> &dsd, 277 sp<Source> *source, 278 DATA_SOURCE_TYPE *dataSourceType); 279 280 void tryOpenAudioSinkForOffload( 281 const sp<AMessage> &format, const sp<MetaData> &audioMeta, bool hasVideo); 282 void closeAudioSink(); 283 void restartAudio( 284 int64_t currentPositionUs, bool forceNonOffload, bool needsToCreateAudioDecoder); 285 void determineAudioModeChange(const sp<AMessage> &audioFormat); 286 287 status_t instantiateDecoder( 288 bool audio, sp<DecoderBase> *decoder, bool checkAudioModeChange = true); 289 290 void updateVideoSize( 291 int64_t srcId, 292 const sp<AMessage> &inputFormat, 293 const sp<AMessage> &outputFormat = NULL); 294 295 void notifyListener(int64_t srcId, int msg, int ext1, int ext2, const Parcel *in = NULL); 296 297 void handleFlushComplete(bool audio, bool isDecoder); 298 void finishFlushIfPossible(); 299 300 void onStart(); 301 void onResume(); 302 void onPause(); 303 304 bool audioDecoderStillNeeded(); 305 306 void flushDecoder(bool audio, bool needShutdown); 307 308 void finishResume(); 309 void notifyDriverSeekComplete(int64_t srcId); 310 311 void postScanSources(); 312 313 void schedulePollDuration(); 314 void cancelPollDuration(); 315 316 void processDeferredActions(); 317 318 void performSeek(int64_t seekTimeUs, MediaPlayer2SeekMode mode); 319 void performDecoderFlush(FlushCommand audio, FlushCommand video); 320 void performReset(); 321 void performPlayNextDataSource(); 322 void performScanSources(); 323 void performSetSurface(const sp<ANativeWindowWrapper> &nw); 324 void performResumeDecoders(bool needNotify); 325 326 void onSourceNotify(const sp<AMessage> &msg); 327 void onClosedCaptionNotify(const sp<AMessage> &msg); 328 329 void queueDecoderShutdown( 330 bool audio, bool video, const sp<AMessage> &reply); 331 332 void sendSubtitleData(const sp<ABuffer> &buffer, int32_t baseIndex); 333 void sendTimedMetaData(const sp<ABuffer> &buffer); 334 void sendTimedTextData(const sp<ABuffer> &buffer); 335 336 void writeTrackInfo(Parcel* reply, const sp<AMessage>& format) const; 337 338 status_t onPrepareDrm(const sp<AMessage> &msg); 339 status_t onReleaseDrm(); 340 341 DISALLOW_EVIL_CONSTRUCTORS(NuPlayer2); 342 }; 343 344 } // namespace android 345 346 #endif // NU_PLAYER2_H_ 347
