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