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 <media/mediaplayer.h>
27
28namespace android {
29
30class DecryptHandle;
31class DrmManagerClient;
32struct AnotherPacketSource;
33struct ARTSPController;
34class DataSource;
35class IDataSource;
36struct IMediaHTTPService;
37struct MediaSource;
38class MediaBuffer;
39struct NuCachedSource2;
40class WVMExtractor;
41
42struct NuPlayer::GenericSource : public NuPlayer::Source {
43    GenericSource(const sp<AMessage> &notify, bool uidValid, uid_t uid);
44
45    status_t setDataSource(
46            const sp<IMediaHTTPService> &httpService,
47            const char *url,
48            const KeyedVector<String8, String8> *headers);
49
50    status_t setDataSource(int fd, int64_t offset, int64_t length);
51
52    status_t setDataSource(const sp<DataSource>& dataSource);
53
54    virtual void prepareAsync();
55
56    virtual void start();
57    virtual void stop();
58    virtual void pause();
59    virtual void resume();
60
61    virtual void disconnect();
62
63    virtual status_t feedMoreTSData();
64
65    virtual sp<MetaData> getFileFormatMeta() const;
66
67    virtual status_t dequeueAccessUnit(bool audio, sp<ABuffer> *accessUnit);
68
69    virtual status_t getDuration(int64_t *durationUs);
70    virtual size_t getTrackCount() const;
71    virtual sp<AMessage> getTrackInfo(size_t trackIndex) const;
72    virtual ssize_t getSelectedTrack(media_track_type type) const;
73    virtual status_t selectTrack(size_t trackIndex, bool select, int64_t timeUs);
74    virtual status_t seekTo(int64_t seekTimeUs);
75
76    virtual status_t setBuffers(bool audio, Vector<MediaBuffer *> &buffers);
77
78    virtual bool isStreaming() const;
79
80    virtual void setOffloadAudio(bool offload);
81
82protected:
83    virtual ~GenericSource();
84
85    virtual void onMessageReceived(const sp<AMessage> &msg);
86
87    virtual sp<MetaData> getFormatMeta(bool audio);
88
89private:
90    enum {
91        kWhatPrepareAsync,
92        kWhatFetchSubtitleData,
93        kWhatFetchTimedTextData,
94        kWhatSendSubtitleData,
95        kWhatSendGlobalTimedTextData,
96        kWhatSendTimedTextData,
97        kWhatChangeAVSource,
98        kWhatPollBuffering,
99        kWhatGetFormat,
100        kWhatGetSelectedTrack,
101        kWhatSelectTrack,
102        kWhatSeek,
103        kWhatReadBuffer,
104        kWhatStopWidevine,
105        kWhatStart,
106        kWhatResume,
107        kWhatSecureDecodersInstantiated,
108    };
109
110    struct Track {
111        size_t mIndex;
112        sp<IMediaSource> mSource;
113        sp<AnotherPacketSource> mPackets;
114    };
115
116    // Helper to monitor buffering status. The polling happens every second.
117    // When necessary, it will send out buffering events to the player.
118    struct BufferingMonitor : public AHandler {
119    public:
120        BufferingMonitor(const sp<AMessage> &notify);
121
122        // Set up state.
123        void prepare(const sp<NuCachedSource2> &cachedSource,
124                const sp<WVMExtractor> &wvmExtractor,
125                int64_t durationUs,
126                int64_t bitrate,
127                bool isStreaming);
128        // Stop and reset buffering monitor.
129        void stop();
130        // Cancel the current monitor task.
131        void cancelPollBuffering();
132        // Restart the monitor task.
133        void restartPollBuffering();
134        // Stop buffering task and send out corresponding events.
135        void stopBufferingIfNecessary();
136        // Make sure data source is getting data.
137        void ensureCacheIsFetching();
138        // Update media time of just extracted buffer from data source.
139        void updateQueuedTime(bool isAudio, int64_t timeUs);
140
141        // Set the offload mode.
142        void setOffloadAudio(bool offload);
143        // Update media time of last dequeued buffer which is sent to the decoder.
144        void updateDequeuedBufferTime(int64_t mediaUs);
145
146    protected:
147        virtual ~BufferingMonitor();
148        virtual void onMessageReceived(const sp<AMessage> &msg);
149
150    private:
151        enum {
152            kWhatPollBuffering,
153        };
154
155        sp<AMessage> mNotify;
156
157        sp<NuCachedSource2> mCachedSource;
158        sp<WVMExtractor> mWVMExtractor;
159        int64_t mDurationUs;
160        int64_t mBitrate;
161        bool mIsStreaming;
162
163        int64_t mAudioTimeUs;
164        int64_t mVideoTimeUs;
165        int32_t mPollBufferingGeneration;
166        bool mPrepareBuffering;
167        bool mBuffering;
168        int32_t mPrevBufferPercentage;
169
170        mutable Mutex mLock;
171
172        bool mOffloadAudio;
173        int64_t mFirstDequeuedBufferRealUs;
174        int64_t mFirstDequeuedBufferMediaUs;
175        int64_t mlastDequeuedBufferMediaUs;
176
177        void prepare_l(const sp<NuCachedSource2> &cachedSource,
178                const sp<WVMExtractor> &wvmExtractor,
179                int64_t durationUs,
180                int64_t bitrate,
181                bool isStreaming);
182        void cancelPollBuffering_l();
183        void notifyBufferingUpdate_l(int32_t percentage);
184        void startBufferingIfNecessary_l();
185        void stopBufferingIfNecessary_l();
186        void sendCacheStats_l();
187        void ensureCacheIsFetching_l();
188        int64_t getLastReadPosition_l();
189        void onPollBuffering_l();
190        void schedulePollBuffering_l();
191    };
192
193    Vector<sp<IMediaSource> > mSources;
194    Track mAudioTrack;
195    int64_t mAudioTimeUs;
196    int64_t mAudioLastDequeueTimeUs;
197    Track mVideoTrack;
198    int64_t mVideoTimeUs;
199    int64_t mVideoLastDequeueTimeUs;
200    Track mSubtitleTrack;
201    Track mTimedTextTrack;
202
203    int32_t mFetchSubtitleDataGeneration;
204    int32_t mFetchTimedTextDataGeneration;
205    int64_t mDurationUs;
206    bool mAudioIsVorbis;
207    bool mIsWidevine;
208    bool mIsSecure;
209    bool mIsStreaming;
210    bool mUIDValid;
211    uid_t mUID;
212    sp<IMediaHTTPService> mHTTPService;
213    AString mUri;
214    KeyedVector<String8, String8> mUriHeaders;
215    int mFd;
216    int64_t mOffset;
217    int64_t mLength;
218
219    sp<DataSource> mDataSource;
220    sp<NuCachedSource2> mCachedSource;
221    sp<DataSource> mHttpSource;
222    sp<WVMExtractor> mWVMExtractor;
223    sp<MetaData> mFileMeta;
224    DrmManagerClient *mDrmManagerClient;
225    sp<DecryptHandle> mDecryptHandle;
226    bool mStarted;
227    bool mStopRead;
228    int64_t mBitrate;
229    sp<BufferingMonitor> mBufferingMonitor;
230    uint32_t mPendingReadBufferTypes;
231    sp<ABuffer> mGlobalTimedText;
232
233    mutable Mutex mReadBufferLock;
234    mutable Mutex mDisconnectLock;
235
236    sp<ALooper> mLooper;
237    sp<ALooper> mBufferingMonitorLooper;
238
239    void resetDataSource();
240
241    status_t initFromDataSource();
242    void checkDrmStatus(const sp<DataSource>& dataSource);
243    int64_t getLastReadPosition();
244    void setDrmPlaybackStatusIfNeeded(int playbackStatus, int64_t position);
245
246    void notifyPreparedAndCleanup(status_t err);
247    void onSecureDecodersInstantiated(status_t err);
248    void finishPrepareAsync();
249    status_t startSources();
250
251    void onGetFormatMeta(sp<AMessage> msg) const;
252    sp<MetaData> doGetFormatMeta(bool audio) const;
253
254    void onGetSelectedTrack(sp<AMessage> msg) const;
255    ssize_t doGetSelectedTrack(media_track_type type) const;
256
257    void onSelectTrack(sp<AMessage> msg);
258    status_t doSelectTrack(size_t trackIndex, bool select, int64_t timeUs);
259
260    void onSeek(sp<AMessage> msg);
261    status_t doSeek(int64_t seekTimeUs);
262
263    void onPrepareAsync();
264
265    void fetchTextData(
266            uint32_t what, media_track_type type,
267            int32_t curGen, sp<AnotherPacketSource> packets, sp<AMessage> msg);
268
269    void sendGlobalTextData(
270            uint32_t what,
271            int32_t curGen, sp<AMessage> msg);
272
273    void sendTextData(
274            uint32_t what, media_track_type type,
275            int32_t curGen, sp<AnotherPacketSource> packets, sp<AMessage> msg);
276
277    sp<ABuffer> mediaBufferToABuffer(
278            MediaBuffer *mbuf,
279            media_track_type trackType,
280            int64_t seekTimeUs,
281            int64_t *actualTimeUs = NULL);
282
283    void postReadBuffer(media_track_type trackType);
284    void onReadBuffer(sp<AMessage> msg);
285    void readBuffer(
286            media_track_type trackType,
287            int64_t seekTimeUs = -1ll, int64_t *actualTimeUs = NULL, bool formatChange = false);
288
289    void queueDiscontinuityIfNeeded(
290            bool seeking, bool formatChange, media_track_type trackType, Track *track);
291
292    DISALLOW_EVIL_CONSTRUCTORS(GenericSource);
293};
294
295}  // namespace android
296
297#endif  // GENERIC_SOURCE_H_
298