1 /* 2 * Copyright (C) 2012 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 GENERIC_SOURCE_H_ 18 19 #define GENERIC_SOURCE_H_ 20 21 #include "NuPlayer.h" 22 #include "NuPlayerSource.h" 23 24 #include "ATSParser.h" 25 26 #include <android-base/unique_fd.h> 27 #include <media/mediaplayer.h> 28 #include <media/stagefright/MediaBuffer.h> 29 30 namespace android { 31 32 class DecryptHandle; 33 struct AnotherPacketSource; 34 struct ARTSPController; 35 class DataSource; 36 class IDataSource; 37 struct IMediaHTTPService; 38 struct MediaSource; 39 class IMediaSource; 40 class MediaBuffer; 41 struct MediaClock; 42 struct NuCachedSource2; 43 44 struct NuPlayer::GenericSource : public NuPlayer::Source, 45 public MediaBufferObserver // Modular DRM 46 { 47 GenericSource(const sp<AMessage> ¬ify, bool uidValid, uid_t uid, 48 const sp<MediaClock> &mediaClock); 49 50 status_t setDataSource( 51 const sp<IMediaHTTPService> &httpService, 52 const char *url, 53 const KeyedVector<String8, String8> *headers); 54 55 status_t setDataSource(int fd, int64_t offset, int64_t length); 56 57 status_t setDataSource(const sp<DataSource>& dataSource); 58 59 virtual status_t getBufferingSettings( 60 BufferingSettings* buffering /* nonnull */) override; 61 virtual status_t setBufferingSettings(const BufferingSettings& buffering) override; 62 63 virtual void prepareAsync(); 64 65 virtual void start(); 66 virtual void stop(); 67 virtual void pause(); 68 virtual void resume(); 69 70 virtual void disconnect(); 71 72 virtual status_t feedMoreTSData(); 73 74 virtual sp<MetaData> getFileFormatMeta() const; 75 76 virtual status_t dequeueAccessUnit(bool audio, sp<ABuffer> *accessUnit); 77 78 virtual status_t getDuration(int64_t *durationUs); 79 virtual size_t getTrackCount() const; 80 virtual sp<AMessage> getTrackInfo(size_t trackIndex) const; 81 virtual ssize_t getSelectedTrack(media_track_type type) const; 82 virtual status_t selectTrack(size_t trackIndex, bool select, int64_t timeUs); 83 virtual status_t seekTo( 84 int64_t seekTimeUs, 85 MediaPlayerSeekMode mode = MediaPlayerSeekMode::SEEK_PREVIOUS_SYNC) override; 86 87 virtual bool isStreaming() const; 88 89 // Modular DRM 90 virtual void signalBufferReturned(MediaBufferBase *buffer); 91 92 virtual status_t prepareDrm( 93 const uint8_t uuid[16], const Vector<uint8_t> &drmSessionId, sp<ICrypto> *outCrypto); 94 95 virtual status_t releaseDrm(); 96 97 98 protected: 99 virtual ~GenericSource(); 100 101 virtual void onMessageReceived(const sp<AMessage> &msg); 102 103 virtual sp<MetaData> getFormatMeta(bool audio); 104 105 private: 106 enum { 107 kWhatPrepareAsync, 108 kWhatFetchSubtitleData, 109 kWhatFetchTimedTextData, 110 kWhatSendSubtitleData, 111 kWhatSendGlobalTimedTextData, 112 kWhatSendTimedTextData, 113 kWhatChangeAVSource, 114 kWhatPollBuffering, 115 kWhatSeek, 116 kWhatReadBuffer, 117 kWhatStart, 118 kWhatResume, 119 kWhatSecureDecodersInstantiated, 120 }; 121 122 struct Track { 123 size_t mIndex; 124 sp<IMediaSource> mSource; 125 sp<AnotherPacketSource> mPackets; 126 }; 127 128 Vector<sp<IMediaSource> > mSources; 129 Track mAudioTrack; 130 int64_t mAudioTimeUs; 131 int64_t mAudioLastDequeueTimeUs; 132 Track mVideoTrack; 133 int64_t mVideoTimeUs; 134 int64_t mVideoLastDequeueTimeUs; 135 Track mSubtitleTrack; 136 Track mTimedTextTrack; 137 138 BufferingSettings mBufferingSettings; 139 int32_t mPrevBufferPercentage; 140 int32_t mPollBufferingGeneration; 141 bool mSentPauseOnBuffering; 142 143 int32_t mAudioDataGeneration; 144 int32_t mVideoDataGeneration; 145 int32_t mFetchSubtitleDataGeneration; 146 int32_t mFetchTimedTextDataGeneration; 147 int64_t mDurationUs; 148 bool mAudioIsVorbis; 149 // Secure codec is required. 150 bool mIsSecure; 151 bool mIsStreaming; 152 bool mUIDValid; 153 uid_t mUID; 154 const sp<MediaClock> mMediaClock; 155 sp<IMediaHTTPService> mHTTPService; 156 AString mUri; 157 KeyedVector<String8, String8> mUriHeaders; 158 base::unique_fd mFd; 159 int64_t mOffset; 160 int64_t mLength; 161 162 bool mDisconnected; 163 sp<DataSource> mDataSource; 164 sp<NuCachedSource2> mCachedSource; 165 sp<DataSource> mHttpSource; 166 sp<MetaData> mFileMeta; 167 bool mStarted; 168 bool mPreparing; 169 int64_t mBitrate; 170 uint32_t mPendingReadBufferTypes; 171 sp<ABuffer> mGlobalTimedText; 172 173 mutable Mutex mLock; 174 mutable Mutex mDisconnectLock; // Protects mDataSource, mHttpSource and mDisconnected 175 176 sp<ALooper> mLooper; 177 178 void resetDataSource(); 179 180 status_t initFromDataSource(); 181 int64_t getLastReadPosition(); 182 183 void notifyPreparedAndCleanup(status_t err); 184 void onSecureDecodersInstantiated(status_t err); 185 void finishPrepareAsync(); 186 status_t startSources(); 187 188 void onSeek(const sp<AMessage>& msg); 189 status_t doSeek(int64_t seekTimeUs, MediaPlayerSeekMode mode); 190 191 void onPrepareAsync(); 192 193 void fetchTextData( 194 uint32_t what, media_track_type type, 195 int32_t curGen, const sp<AnotherPacketSource>& packets, const sp<AMessage>& msg); 196 197 void sendGlobalTextData( 198 uint32_t what, 199 int32_t curGen, sp<AMessage> msg); 200 201 void sendTextData( 202 uint32_t what, media_track_type type, 203 int32_t curGen, const sp<AnotherPacketSource>& packets, const sp<AMessage>& msg); 204 205 sp<ABuffer> mediaBufferToABuffer( 206 MediaBufferBase *mbuf, 207 media_track_type trackType); 208 209 void postReadBuffer(media_track_type trackType); 210 void onReadBuffer(const sp<AMessage>& msg); 211 // When |mode| is MediaPlayerSeekMode::SEEK_CLOSEST, the buffer read shall 212 // include an item indicating skipping rendering all buffers with timestamp 213 // earlier than |seekTimeUs|. 214 // For other modes, the buffer read will not include the item as above in order 215 // to facilitate fast seek operation. 216 void readBuffer( 217 media_track_type trackType, 218 int64_t seekTimeUs = -1ll, 219 MediaPlayerSeekMode mode = MediaPlayerSeekMode::SEEK_PREVIOUS_SYNC, 220 int64_t *actualTimeUs = NULL, bool formatChange = false); 221 222 void queueDiscontinuityIfNeeded( 223 bool seeking, bool formatChange, media_track_type trackType, Track *track); 224 225 void schedulePollBuffering(); 226 void onPollBuffering(); 227 void notifyBufferingUpdate(int32_t percentage); 228 229 void sendCacheStats(); 230 231 sp<MetaData> getFormatMeta_l(bool audio); 232 int32_t getDataGeneration(media_track_type type) const; 233 234 // Modular DRM 235 // The source is DRM protected and is prepared for DRM. 236 bool mIsDrmProtected; 237 // releaseDrm has been processed. 238 bool mIsDrmReleased; 239 Vector<String8> mMimes; 240 241 status_t checkDrmInfo(); 242 243 DISALLOW_EVIL_CONSTRUCTORS(GenericSource); 244 }; 245 246 } // namespace android 247 248 #endif // GENERIC_SOURCE_H_ 249