1 // Copyright 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CONTENT_RENDERER_MEDIA_ANDROID_MEDIA_SOURCE_DELEGATE_H_ 6 #define CONTENT_RENDERER_MEDIA_ANDROID_MEDIA_SOURCE_DELEGATE_H_ 7 8 #include "base/callback.h" 9 #include "base/memory/ref_counted.h" 10 #include "base/memory/scoped_ptr.h" 11 #include "base/memory/weak_ptr.h" 12 #include "base/message_loop/message_loop.h" 13 #include "base/time/time.h" 14 #include "media/base/decryptor.h" 15 #include "media/base/demuxer.h" 16 #include "media/base/media_keys.h" 17 #include "media/base/pipeline_status.h" 18 #include "media/base/ranges.h" 19 #include "media/base/text_track.h" 20 #include "third_party/WebKit/public/web/WebMediaPlayer.h" 21 22 namespace media { 23 class ChunkDemuxer; 24 class DecoderBuffer; 25 class DecryptingDemuxerStream; 26 class DemuxerStream; 27 class MediaLog; 28 struct MediaPlayerHostMsg_DemuxerReady_Params; 29 struct MediaPlayerHostMsg_ReadFromDemuxerAck_Params; 30 } 31 32 namespace content { 33 34 class WebMediaPlayerProxyAndroid; 35 36 class MediaSourceDelegate : public media::DemuxerHost { 37 public: 38 typedef base::Callback<void(WebKit::WebMediaPlayer::NetworkState)> 39 UpdateNetworkStateCB; 40 typedef base::Callback<void(const base::TimeDelta&)> DurationChangeCB; 41 42 // Helper class used by scoped_ptr to destroy an instance of 43 // MediaSourceDelegate. 44 class Destroyer { 45 public: 46 inline void operator()(void* media_source_delegate) const { 47 static_cast<MediaSourceDelegate*>(media_source_delegate)->Destroy(); 48 } 49 }; 50 51 MediaSourceDelegate(WebMediaPlayerProxyAndroid* proxy, 52 int player_id, 53 const scoped_refptr<base::MessageLoopProxy>& media_loop, 54 media::MediaLog* media_log); 55 56 // Initialize the MediaSourceDelegate. |media_source| will be owned by 57 // this object after this call. 58 void InitializeMediaSource( 59 WebKit::WebMediaSource* media_source, 60 const media::NeedKeyCB& need_key_cb, 61 const media::SetDecryptorReadyCB& set_decryptor_ready_cb, 62 const UpdateNetworkStateCB& update_network_state_cb, 63 const DurationChangeCB& duration_change_cb); 64 65 #if defined(GOOGLE_TV) 66 void InitializeMediaStream( 67 media::Demuxer* demuxer, 68 const UpdateNetworkStateCB& update_network_state_cb); 69 #endif 70 71 const WebKit::WebTimeRanges& Buffered(); 72 size_t DecodedFrameCount() const; 73 size_t DroppedFrameCount() const; 74 size_t AudioDecodedByteCount() const; 75 size_t VideoDecodedByteCount() const; 76 77 // Seeks the demuxer and acknowledges the seek request with |seek_request_id| 78 // after the seek has been completed. This method can be called during pending 79 // seeks, in which case only the last seek request will be acknowledged. 80 void Seek(base::TimeDelta time, unsigned seek_request_id); 81 82 void NotifyKeyAdded(const std::string& key_system); 83 84 // Called when DemuxerStreamPlayer needs to read data from ChunkDemuxer. 85 void OnReadFromDemuxer(media::DemuxerStream::Type type); 86 87 // Called when the player needs the new config data from ChunkDemuxer. 88 void OnMediaConfigRequest(); 89 90 // Called by the Destroyer to destroy an instance of this object. 91 void Destroy(); 92 93 private: 94 typedef base::Callback<void( 95 scoped_ptr<media::MediaPlayerHostMsg_ReadFromDemuxerAck_Params> params)> 96 ReadFromDemuxerAckCB; 97 typedef base::Callback<void( 98 scoped_ptr<media::MediaPlayerHostMsg_DemuxerReady_Params> params)> 99 DemuxerReadyCB; 100 101 // This is private to enforce use of the Destroyer. 102 virtual ~MediaSourceDelegate(); 103 104 // Methods inherited from DemuxerHost. 105 virtual void SetTotalBytes(int64 total_bytes) OVERRIDE; 106 virtual void AddBufferedByteRange(int64 start, int64 end) OVERRIDE; 107 virtual void AddBufferedTimeRange(base::TimeDelta start, 108 base::TimeDelta end) OVERRIDE; 109 virtual void SetDuration(base::TimeDelta duration) OVERRIDE; 110 virtual void OnDemuxerError(media::PipelineStatus status) OVERRIDE; 111 112 // Callback for ChunkDemuxer initialization. 113 void OnDemuxerInitDone(media::PipelineStatus status); 114 115 // Initializes DecryptingDemuxerStreams if audio/video stream is encrypted. 116 void InitAudioDecryptingDemuxerStream(); 117 void InitVideoDecryptingDemuxerStream(); 118 119 // Callbacks for DecryptingDemuxerStream::Initialize(). 120 void OnAudioDecryptingDemuxerStreamInitDone(media::PipelineStatus status); 121 void OnVideoDecryptingDemuxerStreamInitDone(media::PipelineStatus status); 122 123 // Callback for Demuxer seek. It will call ResetAudioDecryptingDemuxerStream() 124 // as part of the reset callback chain. 125 void OnDemuxerSeekDone(unsigned seek_request_id, 126 media::PipelineStatus status); 127 128 // Resets AudioDecryptingDemuxerStream if it exists. Then it will call 129 // ResetVideoDecryptingDemuxerStream() as part of the reset callback chain. 130 void ResetAudioDecryptingDemuxerStream(); 131 132 // Resets VideoDecryptingDemuxerStream if it exists. Then it will call 133 // SendSeekRequestAck() as part of the reset callback chain. 134 void ResetVideoDecryptingDemuxerStream(); 135 136 // Sends SeekRequestAck to the browser. 137 void SendSeekRequestAck(); 138 139 void OnDemuxerStopDone(); 140 void OnDemuxerOpened(); 141 void OnNeedKey(const std::string& type, 142 const std::string& session_id, 143 scoped_ptr<uint8[]> init_data, 144 int init_data_size); 145 scoped_ptr<media::TextTrack> OnAddTextTrack(media::TextKind kind, 146 const std::string& label, 147 const std::string& language); 148 void NotifyDemuxerReady(); 149 bool CanNotifyDemuxerReady(); 150 void SendDemuxerReady( 151 scoped_ptr<media::MediaPlayerHostMsg_DemuxerReady_Params> params); 152 153 void StopDemuxer(); 154 void InitializeDemuxer(); 155 void SeekInternal(base::TimeDelta time, unsigned seek_request_id); 156 void OnReadFromDemuxerInternal(media::DemuxerStream::Type type); 157 // Reads an access unit from the demuxer stream |stream| and stores it in 158 // the |index|th access unit in |params|. 159 void ReadFromDemuxerStream( 160 media::DemuxerStream::Type type, 161 scoped_ptr<media::MediaPlayerHostMsg_ReadFromDemuxerAck_Params> params, 162 size_t index); 163 void OnBufferReady( 164 media::DemuxerStream::Type type, 165 scoped_ptr<media::MediaPlayerHostMsg_ReadFromDemuxerAck_Params> params, 166 size_t index, 167 media::DemuxerStream::Status status, 168 const scoped_refptr<media::DecoderBuffer>& buffer); 169 170 void SendReadFromDemuxerAck( 171 scoped_ptr<media::MediaPlayerHostMsg_ReadFromDemuxerAck_Params> params); 172 173 // Helper function for calculating duration. 174 int GetDurationMs(); 175 176 bool HasEncryptedStream(); 177 178 void SetSeeking(bool seeking); 179 bool IsSeeking() const; 180 181 // Weak pointer must be dereferenced and invalidated on the same thread. 182 base::WeakPtrFactory<MediaSourceDelegate> main_weak_this_; 183 base::WeakPtrFactory<MediaSourceDelegate> media_weak_this_; 184 185 // Message loop for main renderer thread. 186 const scoped_refptr<base::MessageLoopProxy> main_loop_; 187 #if defined(GOOGLE_TV) 188 // Message loop for the media thread. 189 // When there is high load in the render thread, the reading from |demuxer_| 190 // and its read-callback loops run very slowly. To improve the response time 191 // of the readings, we run tasks related to |demuxer_| in the media thread. 192 const scoped_refptr<base::MessageLoopProxy> media_loop_; 193 194 ReadFromDemuxerAckCB send_read_from_demuxer_ack_cb_; 195 base::Closure send_seek_request_ack_cb_; 196 DemuxerReadyCB send_demuxer_ready_cb_; 197 #endif 198 199 WebMediaPlayerProxyAndroid* proxy_; 200 int player_id_; 201 202 scoped_refptr<media::MediaLog> media_log_; 203 UpdateNetworkStateCB update_network_state_cb_; 204 DurationChangeCB duration_change_cb_; 205 206 scoped_ptr<media::ChunkDemuxer> chunk_demuxer_; 207 scoped_ptr<WebKit::WebMediaSource> media_source_; 208 media::Demuxer* demuxer_; 209 bool is_demuxer_ready_; 210 211 media::SetDecryptorReadyCB set_decryptor_ready_cb_; 212 213 scoped_ptr<media::DecryptingDemuxerStream> audio_decrypting_demuxer_stream_; 214 scoped_ptr<media::DecryptingDemuxerStream> video_decrypting_demuxer_stream_; 215 216 media::DemuxerStream* audio_stream_; 217 media::DemuxerStream* video_stream_; 218 219 media::PipelineStatistics statistics_; 220 media::Ranges<base::TimeDelta> buffered_time_ranges_; 221 // Keep a list of buffered time ranges. 222 WebKit::WebTimeRanges buffered_web_time_ranges_; 223 224 media::NeedKeyCB need_key_cb_; 225 226 // The currently selected key system. Empty string means that no key system 227 // has been selected. 228 WebKit::WebString current_key_system_; 229 230 // Temporary for EME v0.1. In the future the init data type should be passed 231 // through GenerateKeyRequest() directly from WebKit. 232 std::string init_data_type_; 233 234 // Lock used to serialize access for |seeking_|. 235 mutable base::Lock seeking_lock_; 236 bool seeking_; 237 238 base::TimeDelta last_seek_time_; 239 unsigned last_seek_request_id_; 240 241 bool key_added_; 242 std::string key_system_; 243 244 size_t access_unit_size_; 245 246 DISALLOW_COPY_AND_ASSIGN(MediaSourceDelegate); 247 }; 248 249 } // namespace content 250 251 #endif // CONTENT_RENDERER_MEDIA_ANDROID_MEDIA_SOURCE_DELEGATE_H_ 252