Home | History | Annotate | Download | only in nuplayer 
      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 
     28 namespace android {
     29 
     30 class DecryptHandle;
     31 class DrmManagerClient;
     32 struct AnotherPacketSource;
     33 struct ARTSPController;
     34 struct DataSource;
     35 struct IMediaHTTPService;
     36 struct MediaSource;
     37 class MediaBuffer;
     38 struct NuCachedSource2;
     39 struct WVMExtractor;
     40 
     41 struct NuPlayer::GenericSource : public NuPlayer::Source {
     42     GenericSource(const sp<AMessage> &notify, bool uidValid, uid_t uid);
     43 
     44     status_t setDataSource(
     45             const sp<IMediaHTTPService> &httpService,
     46             const char *url,
     47             const KeyedVector<String8, String8> *headers);
     48 
     49     status_t setDataSource(int fd, int64_t offset, int64_t length);
     50 
     51     virtual void prepareAsync();
     52 
     53     virtual void start();
     54     virtual void stop();
     55     virtual void pause();
     56     virtual void resume();
     57 
     58     virtual void disconnect();
     59 
     60     virtual status_t feedMoreTSData();
     61 
     62     virtual sp<MetaData> getFileFormatMeta() const;
     63 
     64     virtual status_t dequeueAccessUnit(bool audio, sp<ABuffer> *accessUnit);
     65 
     66     virtual status_t getDuration(int64_t *durationUs);
     67     virtual size_t getTrackCount() const;
     68     virtual sp<AMessage> getTrackInfo(size_t trackIndex) const;
     69     virtual ssize_t getSelectedTrack(media_track_type type) const;
     70     virtual status_t selectTrack(size_t trackIndex, bool select);
     71     virtual status_t seekTo(int64_t seekTimeUs);
     72 
     73     virtual status_t setBuffers(bool audio, Vector<MediaBuffer *> &buffers);
     74 
     75 protected:
     76     virtual ~GenericSource();
     77 
     78     virtual void onMessageReceived(const sp<AMessage> &msg);
     79 
     80     virtual sp<MetaData> getFormatMeta(bool audio);
     81 
     82 private:
     83     enum {
     84         kWhatPrepareAsync,
     85         kWhatFetchSubtitleData,
     86         kWhatFetchTimedTextData,
     87         kWhatSendSubtitleData,
     88         kWhatSendTimedTextData,
     89         kWhatChangeAVSource,
     90         kWhatPollBuffering,
     91         kWhatGetFormat,
     92         kWhatGetSelectedTrack,
     93         kWhatSelectTrack,
     94         kWhatSeek,
     95         kWhatReadBuffer,
     96         kWhatStopWidevine,
     97     };
     98 
     99     Vector<sp<MediaSource> > mSources;
    100 
    101     struct Track {
    102         size_t mIndex;
    103         sp<MediaSource> mSource;
    104         sp<AnotherPacketSource> mPackets;
    105     };
    106 
    107     Track mAudioTrack;
    108     int64_t mAudioTimeUs;
    109     Track mVideoTrack;
    110     int64_t mVideoTimeUs;
    111     Track mSubtitleTrack;
    112     Track mTimedTextTrack;
    113 
    114     int32_t mFetchSubtitleDataGeneration;
    115     int32_t mFetchTimedTextDataGeneration;
    116     int64_t mDurationUs;
    117     bool mAudioIsVorbis;
    118     bool mIsWidevine;
    119     bool mUIDValid;
    120     uid_t mUID;
    121     sp<IMediaHTTPService> mHTTPService;
    122     AString mUri;
    123     KeyedVector<String8, String8> mUriHeaders;
    124     int mFd;
    125     int64_t mOffset;
    126     int64_t mLength;
    127 
    128     sp<DataSource> mDataSource;
    129     sp<NuCachedSource2> mCachedSource;
    130     sp<DataSource> mHttpSource;
    131     sp<WVMExtractor> mWVMExtractor;
    132     sp<MetaData> mFileMeta;
    133     DrmManagerClient *mDrmManagerClient;
    134     sp<DecryptHandle> mDecryptHandle;
    135     bool mStarted;
    136     bool mStopRead;
    137     String8 mContentType;
    138     AString mSniffedMIME;
    139     off64_t mMetaDataSize;
    140     int64_t mBitrate;
    141     int32_t mPollBufferingGeneration;
    142     uint32_t mPendingReadBufferTypes;
    143     mutable Mutex mReadBufferLock;
    144 
    145     sp<ALooper> mLooper;
    146 
    147     void resetDataSource();
    148 
    149     status_t initFromDataSource();
    150     void checkDrmStatus(const sp<DataSource>& dataSource);
    151     int64_t getLastReadPosition();
    152     void setDrmPlaybackStatusIfNeeded(int playbackStatus, int64_t position);
    153 
    154     status_t prefillCacheIfNecessary();
    155 
    156     void notifyPreparedAndCleanup(status_t err);
    157 
    158     void onGetFormatMeta(sp<AMessage> msg) const;
    159     sp<MetaData> doGetFormatMeta(bool audio) const;
    160 
    161     void onGetSelectedTrack(sp<AMessage> msg) const;
    162     ssize_t doGetSelectedTrack(media_track_type type) const;
    163 
    164     void onSelectTrack(sp<AMessage> msg);
    165     status_t doSelectTrack(size_t trackIndex, bool select);
    166 
    167     void onSeek(sp<AMessage> msg);
    168     status_t doSeek(int64_t seekTimeUs);
    169 
    170     void onPrepareAsync();
    171 
    172     void fetchTextData(
    173             uint32_t what, media_track_type type,
    174             int32_t curGen, sp<AnotherPacketSource> packets, sp<AMessage> msg);
    175 
    176     void sendTextData(
    177             uint32_t what, media_track_type type,
    178             int32_t curGen, sp<AnotherPacketSource> packets, sp<AMessage> msg);
    179 
    180     sp<ABuffer> mediaBufferToABuffer(
    181             MediaBuffer *mbuf,
    182             media_track_type trackType,
    183             int64_t *actualTimeUs = NULL);
    184 
    185     void postReadBuffer(media_track_type trackType);
    186     void onReadBuffer(sp<AMessage> msg);
    187     void readBuffer(
    188             media_track_type trackType,
    189             int64_t seekTimeUs = -1ll, int64_t *actualTimeUs = NULL, bool formatChange = false);
    190 
    191     void schedulePollBuffering();
    192     void cancelPollBuffering();
    193     void onPollBuffering();
    194     void notifyBufferingUpdate(int percentage);
    195 
    196     DISALLOW_EVIL_CONSTRUCTORS(GenericSource);
    197 };
    198 
    199 }  // namespace android
    200 
    201 #endif  // GENERIC_SOURCE_H_
    202