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 #include "media/base/text_renderer.h"
6
7 #include "base/bind.h"
8 #include "base/callback_helpers.h"
9 #include "base/logging.h"
10 #include "base/message_loop/message_loop_proxy.h"
11 #include "base/stl_util.h"
12 #include "media/base/bind_to_loop.h"
13 #include "media/base/decoder_buffer.h"
14 #include "media/base/demuxer.h"
15 #include "media/base/demuxer_stream.h"
16 #include "media/base/text_cue.h"
17
18 namespace media {
19
TextRenderer(const scoped_refptr<base::MessageLoopProxy> & message_loop,const AddTextTrackCB & add_text_track_cb)20 TextRenderer::TextRenderer(
21 const scoped_refptr<base::MessageLoopProxy>& message_loop,
22 const AddTextTrackCB& add_text_track_cb)
23 : message_loop_(message_loop),
24 weak_factory_(this),
25 add_text_track_cb_(add_text_track_cb),
26 state_(kUninitialized),
27 pending_read_count_(0) {
28 }
29
~TextRenderer()30 TextRenderer::~TextRenderer() {
31 DCHECK(state_ == kUninitialized ||
32 state_ == kStopped) << "state_ " << state_;
33 DCHECK_EQ(pending_read_count_, 0);
34 STLDeleteValues(&text_track_state_map_);
35 }
36
Initialize(const base::Closure & ended_cb)37 void TextRenderer::Initialize(const base::Closure& ended_cb) {
38 DCHECK(message_loop_->BelongsToCurrentThread());
39 DCHECK(!ended_cb.is_null());
40 DCHECK_EQ(kUninitialized, state_) << "state_ " << state_;
41 DCHECK(text_track_state_map_.empty());
42 DCHECK_EQ(pending_read_count_, 0);
43 DCHECK(pending_eos_set_.empty());
44 DCHECK(ended_cb_.is_null());
45
46 weak_this_ = weak_factory_.GetWeakPtr();
47 ended_cb_ = ended_cb;
48 state_ = kPaused;
49 }
50
Play(const base::Closure & callback)51 void TextRenderer::Play(const base::Closure& callback) {
52 DCHECK(message_loop_->BelongsToCurrentThread());
53 DCHECK_EQ(state_, kPaused) << "state_ " << state_;
54
55 for (TextTrackStateMap::iterator itr = text_track_state_map_.begin();
56 itr != text_track_state_map_.end(); ++itr) {
57 TextTrackState* state = itr->second;
58 if (state->read_state == TextTrackState::kReadPending) {
59 DCHECK_GT(pending_read_count_, 0);
60 continue;
61 }
62
63 Read(state, itr->first);
64 }
65
66 state_ = kPlaying;
67 callback.Run();
68 }
69
Pause(const base::Closure & callback)70 void TextRenderer::Pause(const base::Closure& callback) {
71 DCHECK(message_loop_->BelongsToCurrentThread());
72 DCHECK(state_ == kPlaying || state_ == kEnded) << "state_ " << state_;
73 DCHECK_GE(pending_read_count_, 0);
74 pause_cb_ = callback;
75
76 if (pending_read_count_ == 0) {
77 state_ = kPaused;
78 base::ResetAndReturn(&pause_cb_).Run();
79 return;
80 }
81
82 state_ = kPausePending;
83 }
84
Flush(const base::Closure & callback)85 void TextRenderer::Flush(const base::Closure& callback) {
86 DCHECK(message_loop_->BelongsToCurrentThread());
87 DCHECK_EQ(pending_read_count_, 0);
88 DCHECK(state_ == kPaused) << "state_ " << state_;
89
90 for (TextTrackStateMap::iterator itr = text_track_state_map_.begin();
91 itr != text_track_state_map_.end(); ++itr) {
92 pending_eos_set_.insert(itr->first);
93 }
94 DCHECK_EQ(pending_eos_set_.size(), text_track_state_map_.size());
95 callback.Run();
96 }
97
Stop(const base::Closure & cb)98 void TextRenderer::Stop(const base::Closure& cb) {
99 DCHECK(message_loop_->BelongsToCurrentThread());
100 DCHECK(!cb.is_null());
101 DCHECK(state_ == kPlaying ||
102 state_ == kPausePending ||
103 state_ == kPaused ||
104 state_ == kEnded) << "state_ " << state_;
105 DCHECK_GE(pending_read_count_, 0);
106
107 stop_cb_ = cb;
108
109 if (pending_read_count_ == 0) {
110 state_ = kStopped;
111 base::ResetAndReturn(&stop_cb_).Run();
112 return;
113 }
114
115 state_ = kStopPending;
116 }
117
AddTextStream(DemuxerStream * text_stream,const TextTrackConfig & config)118 void TextRenderer::AddTextStream(DemuxerStream* text_stream,
119 const TextTrackConfig& config) {
120 DCHECK(message_loop_->BelongsToCurrentThread());
121 DCHECK(state_ != kUninitialized) << "state_ " << state_;
122 DCHECK_NE(state_, kStopPending);
123 DCHECK_NE(state_, kStopped);
124 DCHECK(text_track_state_map_.find(text_stream) ==
125 text_track_state_map_.end());
126 DCHECK(pending_eos_set_.find(text_stream) ==
127 pending_eos_set_.end());
128
129 media::AddTextTrackDoneCB done_cb =
130 media::BindToLoop(message_loop_,
131 base::Bind(&TextRenderer::OnAddTextTrackDone,
132 weak_this_,
133 text_stream));
134
135 add_text_track_cb_.Run(config, done_cb);
136 }
137
RemoveTextStream(DemuxerStream * text_stream)138 void TextRenderer::RemoveTextStream(DemuxerStream* text_stream) {
139 DCHECK(message_loop_->BelongsToCurrentThread());
140
141 TextTrackStateMap::iterator itr = text_track_state_map_.find(text_stream);
142 DCHECK(itr != text_track_state_map_.end());
143
144 TextTrackState* state = itr->second;
145 DCHECK_EQ(state->read_state, TextTrackState::kReadIdle);
146 delete state;
147 text_track_state_map_.erase(itr);
148
149 pending_eos_set_.erase(text_stream);
150 }
151
HasTracks() const152 bool TextRenderer::HasTracks() const {
153 DCHECK(message_loop_->BelongsToCurrentThread());
154 return !text_track_state_map_.empty();
155 }
156
BufferReady(DemuxerStream * stream,DemuxerStream::Status status,const scoped_refptr<DecoderBuffer> & input)157 void TextRenderer::BufferReady(
158 DemuxerStream* stream,
159 DemuxerStream::Status status,
160 const scoped_refptr<DecoderBuffer>& input) {
161 DCHECK(message_loop_->BelongsToCurrentThread());
162 DCHECK_NE(status, DemuxerStream::kConfigChanged);
163
164 if (status == DemuxerStream::kAborted) {
165 DCHECK(!input);
166 DCHECK_GT(pending_read_count_, 0);
167 DCHECK(pending_eos_set_.find(stream) != pending_eos_set_.end());
168
169 TextTrackStateMap::iterator itr = text_track_state_map_.find(stream);
170 DCHECK(itr != text_track_state_map_.end());
171
172 TextTrackState* state = itr->second;
173 DCHECK_EQ(state->read_state, TextTrackState::kReadPending);
174
175 --pending_read_count_;
176 state->read_state = TextTrackState::kReadIdle;
177
178 switch (state_) {
179 case kPlaying:
180 return;
181
182 case kPausePending:
183 if (pending_read_count_ == 0) {
184 state_ = kPaused;
185 base::ResetAndReturn(&pause_cb_).Run();
186 }
187
188 return;
189
190 case kStopPending:
191 if (pending_read_count_ == 0) {
192 state_ = kStopped;
193 base::ResetAndReturn(&stop_cb_).Run();
194 }
195
196 return;
197
198 case kPaused:
199 case kStopped:
200 case kUninitialized:
201 case kEnded:
202 NOTREACHED();
203 return;
204 }
205
206 NOTREACHED();
207 return;
208 }
209
210 if (input->end_of_stream()) {
211 CueReady(stream, NULL);
212 return;
213 }
214
215 DCHECK_EQ(status, DemuxerStream::kOk);
216 DCHECK_GE(input->side_data_size(), 2);
217
218 // The side data contains both the cue id and cue settings,
219 // each terminated with a NUL.
220 const char* id_ptr = reinterpret_cast<const char*>(input->side_data());
221 size_t id_len = strlen(id_ptr);
222 std::string id(id_ptr, id_len);
223
224 const char* settings_ptr = id_ptr + id_len + 1;
225 size_t settings_len = strlen(settings_ptr);
226 std::string settings(settings_ptr, settings_len);
227
228 // The cue payload is stored in the data-part of the input buffer.
229 std::string text(input->data(), input->data() + input->data_size());
230
231 scoped_refptr<TextCue> text_cue(
232 new TextCue(input->timestamp(),
233 input->duration(),
234 id,
235 settings,
236 text));
237
238 CueReady(stream, text_cue);
239 }
240
CueReady(DemuxerStream * text_stream,const scoped_refptr<TextCue> & text_cue)241 void TextRenderer::CueReady(
242 DemuxerStream* text_stream,
243 const scoped_refptr<TextCue>& text_cue) {
244 DCHECK(message_loop_->BelongsToCurrentThread());
245 DCHECK(state_ != kUninitialized &&
246 state_ != kStopped) << "state_ " << state_;
247 DCHECK_GT(pending_read_count_, 0);
248 DCHECK(pending_eos_set_.find(text_stream) != pending_eos_set_.end());
249
250 TextTrackStateMap::iterator itr = text_track_state_map_.find(text_stream);
251 DCHECK(itr != text_track_state_map_.end());
252
253 TextTrackState* state = itr->second;
254 DCHECK_EQ(state->read_state, TextTrackState::kReadPending);
255 DCHECK(state->text_track);
256
257 --pending_read_count_;
258 state->read_state = TextTrackState::kReadIdle;
259
260 switch (state_) {
261 case kPlaying: {
262 if (text_cue)
263 break;
264
265 const size_t count = pending_eos_set_.erase(text_stream);
266 DCHECK_EQ(count, 1U);
267
268 if (pending_eos_set_.empty()) {
269 DCHECK_EQ(pending_read_count_, 0);
270 state_ = kEnded;
271 ended_cb_.Run();
272 return;
273 }
274
275 DCHECK_GT(pending_read_count_, 0);
276 return;
277 }
278 case kPausePending: {
279 if (text_cue)
280 break;
281
282 const size_t count = pending_eos_set_.erase(text_stream);
283 DCHECK_EQ(count, 1U);
284
285 if (pending_read_count_ > 0) {
286 DCHECK(!pending_eos_set_.empty());
287 return;
288 }
289
290 state_ = kPaused;
291 base::ResetAndReturn(&pause_cb_).Run();
292
293 return;
294 }
295 case kStopPending:
296 if (pending_read_count_ == 0) {
297 state_ = kStopped;
298 base::ResetAndReturn(&stop_cb_).Run();
299 }
300
301 return;
302
303 case kPaused:
304 case kStopped:
305 case kUninitialized:
306 case kEnded:
307 NOTREACHED();
308 return;
309 }
310
311 base::TimeDelta start = text_cue->timestamp();
312 base::TimeDelta end = start + text_cue->duration();
313
314 state->text_track->addWebVTTCue(start, end,
315 text_cue->id(),
316 text_cue->text(),
317 text_cue->settings());
318
319 if (state_ == kPlaying) {
320 Read(state, text_stream);
321 return;
322 }
323
324 if (pending_read_count_ == 0) {
325 DCHECK_EQ(state_, kPausePending) << "state_ " << state_;
326 state_ = kPaused;
327 base::ResetAndReturn(&pause_cb_).Run();
328 }
329 }
330
OnAddTextTrackDone(DemuxerStream * text_stream,scoped_ptr<TextTrack> text_track)331 void TextRenderer::OnAddTextTrackDone(DemuxerStream* text_stream,
332 scoped_ptr<TextTrack> text_track) {
333 DCHECK(message_loop_->BelongsToCurrentThread());
334 DCHECK(state_ != kUninitialized &&
335 state_ != kStopped &&
336 state_ != kStopPending) << "state_ " << state_;
337 DCHECK(text_stream);
338 DCHECK(text_track);
339
340 scoped_ptr<TextTrackState> state(new TextTrackState(text_track.Pass()));
341 text_track_state_map_[text_stream] = state.release();
342 pending_eos_set_.insert(text_stream);
343
344 if (state_ == kPlaying)
345 Read(text_track_state_map_[text_stream], text_stream);
346 }
347
Read(TextTrackState * state,DemuxerStream * text_stream)348 void TextRenderer::Read(
349 TextTrackState* state,
350 DemuxerStream* text_stream) {
351 DCHECK_NE(state->read_state, TextTrackState::kReadPending);
352
353 state->read_state = TextTrackState::kReadPending;
354 ++pending_read_count_;
355
356 text_stream->Read(base::Bind(&TextRenderer::BufferReady,
357 weak_this_,
358 text_stream));
359 }
360
TextTrackState(scoped_ptr<TextTrack> tt)361 TextRenderer::TextTrackState::TextTrackState(scoped_ptr<TextTrack> tt)
362 : read_state(kReadIdle),
363 text_track(tt.Pass()) {
364 }
365
~TextTrackState()366 TextRenderer::TextTrackState::~TextTrackState() {
367 }
368
369 } // namespace media
370