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 struct AnotherPacketSource;
     32 struct ARTSPController;
     33 class DataSource;
     34 class IDataSource;
     35 struct IMediaHTTPService;
     36 struct MediaSource;
     37 class MediaBuffer;
     38 struct NuCachedSource2;
     39 
     40 struct NuPlayer::GenericSource : public NuPlayer::Source,
     41                                  public MediaBufferObserver // Modular DRM
     42 {
     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 status_t getDefaultBufferingSettings(
     55             BufferingSettings* buffering /* nonnull */) override;
     56     virtual status_t setBufferingSettings(const BufferingSettings& buffering) override;
     57 
     58     virtual void prepareAsync();
     59 
     60     virtual void start();
     61     virtual void stop();
     62     virtual void pause();
     63     virtual void resume();
     64 
     65     virtual void disconnect();
     66 
     67     virtual status_t feedMoreTSData();
     68 
     69     virtual sp<MetaData> getFileFormatMeta() const;
     70 
     71     virtual status_t dequeueAccessUnit(bool audio, sp<ABuffer> *accessUnit);
     72 
     73     virtual status_t getDuration(int64_t *durationUs);
     74     virtual size_t getTrackCount() const;
     75     virtual sp<AMessage> getTrackInfo(size_t trackIndex) const;
     76     virtual ssize_t getSelectedTrack(media_track_type type) const;
     77     virtual status_t selectTrack(size_t trackIndex, bool select, int64_t timeUs);
     78     virtual status_t seekTo(
     79         int64_t seekTimeUs,
     80         MediaPlayerSeekMode mode = MediaPlayerSeekMode::SEEK_PREVIOUS_SYNC) override;
     81 
     82     virtual status_t setBuffers(bool audio, Vector<MediaBuffer *> &buffers);
     83 
     84     virtual bool isStreaming() const;
     85 
     86     virtual void setOffloadAudio(bool offload);
     87 
     88     // Modular DRM
     89     virtual void signalBufferReturned(MediaBuffer *buffer);
     90 
     91     virtual status_t prepareDrm(
     92             const uint8_t uuid[16], const Vector<uint8_t> &drmSessionId, sp<ICrypto> *crypto);
     93 
     94     virtual status_t releaseDrm();
     95 
     96 
     97 protected:
     98     virtual ~GenericSource();
     99 
    100     virtual void onMessageReceived(const sp<AMessage> &msg);
    101 
    102     virtual sp<MetaData> getFormatMeta(bool audio);
    103 
    104 private:
    105     enum {
    106         kWhatPrepareAsync,
    107         kWhatFetchSubtitleData,
    108         kWhatFetchTimedTextData,
    109         kWhatSendSubtitleData,
    110         kWhatSendGlobalTimedTextData,
    111         kWhatSendTimedTextData,
    112         kWhatChangeAVSource,
    113         kWhatPollBuffering,
    114         kWhatGetFormat,
    115         kWhatGetSelectedTrack,
    116         kWhatSelectTrack,
    117         kWhatSeek,
    118         kWhatReadBuffer,
    119         kWhatStart,
    120         kWhatResume,
    121         kWhatSecureDecodersInstantiated,
    122         // Modular DRM
    123         kWhatPrepareDrm,
    124         kWhatReleaseDrm,
    125     };
    126 
    127     struct Track {
    128         size_t mIndex;
    129         sp<IMediaSource> mSource;
    130         sp<AnotherPacketSource> mPackets;
    131     };
    132 
    133     // Helper to monitor buffering status. The polling happens every second.
    134     // When necessary, it will send out buffering events to the player.
    135     struct BufferingMonitor : public AHandler {
    136     public:
    137         explicit BufferingMonitor(const sp<AMessage> &notify);
    138 
    139         void getDefaultBufferingSettings(BufferingSettings *buffering /* nonnull */);
    140         status_t setBufferingSettings(const BufferingSettings &buffering);
    141 
    142         // Set up state.
    143         void prepare(const sp<NuCachedSource2> &cachedSource,
    144                 int64_t durationUs,
    145                 int64_t bitrate,
    146                 bool isStreaming);
    147         // Stop and reset buffering monitor.
    148         void stop();
    149         // Cancel the current monitor task.
    150         void cancelPollBuffering();
    151         // Restart the monitor task.
    152         void restartPollBuffering();
    153         // Stop buffering task and send out corresponding events.
    154         void stopBufferingIfNecessary();
    155         // Make sure data source is getting data.
    156         void ensureCacheIsFetching();
    157         // Update media time of just extracted buffer from data source.
    158         void updateQueuedTime(bool isAudio, int64_t timeUs);
    159 
    160         // Set the offload mode.
    161         void setOffloadAudio(bool offload);
    162         // Update media time of last dequeued buffer which is sent to the decoder.
    163         void updateDequeuedBufferTime(int64_t mediaUs);
    164 
    165     protected:
    166         virtual ~BufferingMonitor();
    167         virtual void onMessageReceived(const sp<AMessage> &msg);
    168 
    169     private:
    170         enum {
    171             kWhatPollBuffering,
    172         };
    173 
    174         sp<AMessage> mNotify;
    175 
    176         sp<NuCachedSource2> mCachedSource;
    177         int64_t mDurationUs;
    178         int64_t mBitrate;
    179         bool mIsStreaming;
    180 
    181         int64_t mAudioTimeUs;
    182         int64_t mVideoTimeUs;
    183         int32_t mPollBufferingGeneration;
    184         bool mPrepareBuffering;
    185         bool mBuffering;
    186         int32_t mPrevBufferPercentage;
    187 
    188         mutable Mutex mLock;
    189 
    190         BufferingSettings mSettings;
    191         bool mOffloadAudio;
    192         int64_t mFirstDequeuedBufferRealUs;
    193         int64_t mFirstDequeuedBufferMediaUs;
    194         int64_t mlastDequeuedBufferMediaUs;
    195 
    196         void prepare_l(const sp<NuCachedSource2> &cachedSource,
    197                 int64_t durationUs,
    198                 int64_t bitrate,
    199                 bool isStreaming);
    200         void cancelPollBuffering_l();
    201         void notifyBufferingUpdate_l(int32_t percentage);
    202         void startBufferingIfNecessary_l();
    203         void stopBufferingIfNecessary_l();
    204         void sendCacheStats_l();
    205         void ensureCacheIsFetching_l();
    206         int64_t getLastReadPosition_l();
    207         void onPollBuffering_l();
    208         void schedulePollBuffering_l();
    209     };
    210 
    211     Vector<sp<IMediaSource> > mSources;
    212     Track mAudioTrack;
    213     int64_t mAudioTimeUs;
    214     int64_t mAudioLastDequeueTimeUs;
    215     Track mVideoTrack;
    216     int64_t mVideoTimeUs;
    217     int64_t mVideoLastDequeueTimeUs;
    218     Track mSubtitleTrack;
    219     Track mTimedTextTrack;
    220 
    221     int32_t mFetchSubtitleDataGeneration;
    222     int32_t mFetchTimedTextDataGeneration;
    223     int64_t mDurationUs;
    224     bool mAudioIsVorbis;
    225     // Secure codec is required.
    226     bool mIsSecure;
    227     bool mIsStreaming;
    228     bool mUIDValid;
    229     uid_t mUID;
    230     sp<IMediaHTTPService> mHTTPService;
    231     AString mUri;
    232     KeyedVector<String8, String8> mUriHeaders;
    233     int mFd;
    234     int64_t mOffset;
    235     int64_t mLength;
    236 
    237     sp<DataSource> mDataSource;
    238     sp<NuCachedSource2> mCachedSource;
    239     sp<DataSource> mHttpSource;
    240     sp<MetaData> mFileMeta;
    241     bool mStarted;
    242     bool mStopRead;
    243     int64_t mBitrate;
    244     sp<BufferingMonitor> mBufferingMonitor;
    245     uint32_t mPendingReadBufferTypes;
    246     sp<ABuffer> mGlobalTimedText;
    247 
    248     mutable Mutex mReadBufferLock;
    249     mutable Mutex mDisconnectLock;
    250 
    251     sp<ALooper> mLooper;
    252     sp<ALooper> mBufferingMonitorLooper;
    253 
    254     void resetDataSource();
    255 
    256     status_t initFromDataSource();
    257     int64_t getLastReadPosition();
    258 
    259     void notifyPreparedAndCleanup(status_t err);
    260     void onSecureDecodersInstantiated(status_t err);
    261     void finishPrepareAsync();
    262     status_t startSources();
    263 
    264     void onGetFormatMeta(const sp<AMessage>& msg) const;
    265     sp<MetaData> doGetFormatMeta(bool audio) const;
    266 
    267     void onGetTrackInfo(const sp<AMessage>& msg) const;
    268     sp<AMessage> doGetTrackInfo(size_t trackIndex) const;
    269 
    270     void onGetSelectedTrack(const sp<AMessage>& msg) const;
    271     ssize_t doGetSelectedTrack(media_track_type type) const;
    272 
    273     void onSelectTrack(const sp<AMessage>& msg);
    274     status_t doSelectTrack(size_t trackIndex, bool select, int64_t timeUs);
    275 
    276     void onSeek(const sp<AMessage>& msg);
    277     status_t doSeek(int64_t seekTimeUs, MediaPlayerSeekMode mode);
    278 
    279     void onPrepareAsync();
    280 
    281     void fetchTextData(
    282             uint32_t what, media_track_type type,
    283             int32_t curGen, const sp<AnotherPacketSource>& packets, const sp<AMessage>& msg);
    284 
    285     void sendGlobalTextData(
    286             uint32_t what,
    287             int32_t curGen, sp<AMessage> msg);
    288 
    289     void sendTextData(
    290             uint32_t what, media_track_type type,
    291             int32_t curGen, const sp<AnotherPacketSource>& packets, const sp<AMessage>& msg);
    292 
    293     sp<ABuffer> mediaBufferToABuffer(
    294             MediaBuffer *mbuf,
    295             media_track_type trackType);
    296 
    297     void postReadBuffer(media_track_type trackType);
    298     void onReadBuffer(const sp<AMessage>& msg);
    299     // When |mode| is MediaPlayerSeekMode::SEEK_CLOSEST, the buffer read shall
    300     // include an item indicating skipping rendering all buffers with timestamp
    301     // earlier than |seekTimeUs|.
    302     // For other modes, the buffer read will not include the item as above in order
    303     // to facilitate fast seek operation.
    304     void readBuffer(
    305             media_track_type trackType,
    306             int64_t seekTimeUs = -1ll,
    307             MediaPlayerSeekMode mode = MediaPlayerSeekMode::SEEK_PREVIOUS_SYNC,
    308             int64_t *actualTimeUs = NULL, bool formatChange = false);
    309 
    310     void queueDiscontinuityIfNeeded(
    311             bool seeking, bool formatChange, media_track_type trackType, Track *track);
    312 
    313     // Modular DRM
    314     // The source is DRM protected and is prepared for DRM.
    315     bool mIsDrmProtected;
    316     // releaseDrm has been processed.
    317     bool mIsDrmReleased;
    318     Vector<String8> mMimes;
    319 
    320     status_t checkDrmInfo();
    321     status_t onPrepareDrm(const sp<AMessage> &msg);
    322     status_t onReleaseDrm();
    323 
    324     DISALLOW_EVIL_CONSTRUCTORS(GenericSource);
    325 };
    326 
    327 }  // namespace android
    328 
    329 #endif  // GENERIC_SOURCE_H_
    330