1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
|
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef MEDIA_BLINK_BUFFERED_DATA_SOURCE_H_
#define MEDIA_BLINK_BUFFERED_DATA_SOURCE_H_
#include <string>
#include <vector>
#include "base/callback.h"
#include "base/memory/scoped_ptr.h"
#include "base/synchronization/lock.h"
#include "media/base/data_source.h"
#include "media/base/media_export.h"
#include "media/base/ranges.h"
#include "media/blink/buffered_resource_loader.h"
#include "url/gurl.h"
namespace base {
class SingleThreadTaskRunner;
}
namespace media {
class MediaLog;
class MEDIA_EXPORT BufferedDataSourceHost {
public:
// Notify the host of the total size of the media file.
virtual void SetTotalBytes(int64 total_bytes) = 0;
// Notify the host that byte range [start,end] has been buffered.
// TODO(fischman): remove this method when demuxing is push-based instead of
// pull-based. http://crbug.com/131444
virtual void AddBufferedByteRange(int64 start, int64 end) = 0;
protected:
virtual ~BufferedDataSourceHost() {};
};
// A data source capable of loading URLs and buffering the data using an
// in-memory sliding window.
//
// BufferedDataSource must be created and initialized on the render thread
// before being passed to other threads. It may be deleted on any thread.
class MEDIA_EXPORT BufferedDataSource : public DataSource {
public:
// Used to specify video preload states. They are "hints" to the browser about
// how aggressively the browser should load and buffer data.
// Please see the HTML5 spec for the descriptions of these values:
// http://www.w3.org/TR/html5/video.html#attr-media-preload
//
// Enum values must match the values in blink::WebMediaPlayer::Preload and
// there will be assertions at compile time if they do not match.
enum Preload {
NONE,
METADATA,
AUTO,
};
typedef base::Callback<void(bool)> DownloadingCB;
// |url| and |cors_mode| are passed to the object. Buffered byte range changes
// will be reported to |host|. |downloading_cb| will be called whenever the
// downloading/paused state of the source changes.
BufferedDataSource(
const GURL& url,
BufferedResourceLoader::CORSMode cors_mode,
const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
blink::WebFrame* frame,
MediaLog* media_log,
BufferedDataSourceHost* host,
const DownloadingCB& downloading_cb);
~BufferedDataSource() override;
// Executes |init_cb| with the result of initialization when it has completed.
//
// Method called on the render thread.
typedef base::Callback<void(bool)> InitializeCB;
void Initialize(const InitializeCB& init_cb);
// Adjusts the buffering algorithm based on the given preload value.
void SetPreload(Preload preload);
// Returns true if the media resource has a single origin, false otherwise.
// Only valid to call after Initialize() has completed.
//
// Method called on the render thread.
bool HasSingleOrigin();
// Returns true if the media resource passed a CORS access control check.
bool DidPassCORSAccessCheck() const;
// Cancels initialization, any pending loaders, and any pending read calls
// from the demuxer. The caller is expected to release its reference to this
// object and never call it again.
//
// Method called on the render thread.
void Abort();
// Notifies changes in playback state for controlling media buffering
// behavior.
void MediaPlaybackRateChanged(float playback_rate);
void MediaIsPlaying();
void MediaIsPaused();
// Returns true if the resource is local.
bool assume_fully_buffered() { return !url_.SchemeIsHTTPOrHTTPS(); }
// DataSource implementation.
// Called from demuxer thread.
void Stop() override;
void Read(int64 position,
int size,
uint8* data,
const DataSource::ReadCB& read_cb) override;
bool GetSize(int64* size_out) override;
bool IsStreaming() override;
void SetBitrate(int bitrate) override;
protected:
// A factory method to create a BufferedResourceLoader based on the read
// parameters. We can override this file to object a mock
// BufferedResourceLoader for testing.
virtual BufferedResourceLoader* CreateResourceLoader(
int64 first_byte_position, int64 last_byte_position);
private:
friend class BufferedDataSourceTest;
// Task posted to perform actual reading on the render thread.
void ReadTask();
// Cancels oustanding callbacks and sets |stop_signal_received_|. Safe to call
// from any thread.
void StopInternal_Locked();
// Stops |loader_| if present. Used by Abort() and Stop().
void StopLoader();
// Tells |loader_| the bitrate of the media.
void SetBitrateTask(int bitrate);
// The method that performs actual read. This method can only be executed on
// the render thread.
void ReadInternal();
// BufferedResourceLoader::Start() callback for initial load.
void StartCallback(BufferedResourceLoader::Status status);
// BufferedResourceLoader::Start() callback for subsequent loads (i.e.,
// when accessing ranges that are outside initial buffered region).
void PartialReadStartCallback(BufferedResourceLoader::Status status);
// BufferedResourceLoader callbacks.
void ReadCallback(BufferedResourceLoader::Status status, int bytes_read);
void LoadingStateChangedCallback(BufferedResourceLoader::LoadingState state);
void ProgressCallback(int64 position);
// Update |loader_|'s deferring strategy in response to a play/pause, or
// change in playback rate.
void UpdateDeferStrategy(bool paused);
// URL of the resource requested.
GURL url_;
// crossorigin attribute on the corresponding HTML media element, if any.
BufferedResourceLoader::CORSMode cors_mode_;
// The total size of the resource. Set during StartCallback() if the size is
// known, otherwise it will remain kPositionNotSpecified until the size is
// determined by reaching EOF.
int64 total_bytes_;
// This value will be true if this data source can only support streaming.
// i.e. range request is not supported.
bool streaming_;
// A webframe for loading.
blink::WebFrame* frame_;
// A resource loader for the media resource.
scoped_ptr<BufferedResourceLoader> loader_;
// Callback method from the pipeline for initialization.
InitializeCB init_cb_;
// Read parameters received from the Read() method call. Must be accessed
// under |lock_|.
class ReadOperation;
scoped_ptr<ReadOperation> read_op_;
// This buffer is intermediate, we use it for BufferedResourceLoader to write
// to. And when read in BufferedResourceLoader is done, we copy data from
// this buffer to |read_buffer_|. The reason for an additional copy is that
// we don't own |read_buffer_|. But since the read operation is asynchronous,
// |read_buffer| can be destroyed at any time, so we only copy into
// |read_buffer| in the final step when it is safe.
// Memory is allocated for this member during initialization of this object
// because we want buffer to be passed into BufferedResourceLoader to be
// always non-null. And by initializing this member with a default size we can
// avoid creating zero-sized buffered if the first read has zero size.
std::vector<uint8> intermediate_read_buffer_;
// The task runner of the render thread.
const scoped_refptr<base::SingleThreadTaskRunner> render_task_runner_;
// Protects |stop_signal_received_| and |read_op_|.
base::Lock lock_;
// Whether we've been told to stop via Abort() or Stop().
bool stop_signal_received_;
// This variable is true when the user has requested the video to play at
// least once.
bool media_has_played_;
// This variable holds the value of the preload attribute for the video
// element.
Preload preload_;
// Bitrate of the content, 0 if unknown.
int bitrate_;
// Current playback rate.
float playback_rate_;
scoped_refptr<MediaLog> media_log_;
// Host object to report buffered byte range changes to.
BufferedDataSourceHost* host_;
DownloadingCB downloading_cb_;
// NOTE: Weak pointers must be invalidated before all other member variables.
base::WeakPtrFactory<BufferedDataSource> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(BufferedDataSource);
};
} // namespace media
#endif // MEDIA_BLINK_BUFFERED_DATA_SOURCE_H_
|