Replace WTF::move with WTFMove
[WebKit-https.git] / Source / WebCore / Modules / mediasource / MediaSource.cpp
1 /*
2  * Copyright (C) 2013 Google Inc. All rights reserved.
3  * Copyright (C) 2013-2014 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #include "config.h"
33 #include "MediaSource.h"
34
35 #if ENABLE(MEDIA_SOURCE)
36
37 #include "AudioTrack.h"
38 #include "AudioTrackList.h"
39 #include "ContentType.h"
40 #include "Event.h"
41 #include "ExceptionCode.h"
42 #include "ExceptionCodePlaceholder.h"
43 #include "GenericEventQueue.h"
44 #include "HTMLMediaElement.h"
45 #include "Logging.h"
46 #include "MIMETypeRegistry.h"
47 #include "MediaError.h"
48 #include "MediaPlayer.h"
49 #include "MediaSourceRegistry.h"
50 #include "SourceBufferPrivate.h"
51 #include "TextTrack.h"
52 #include "TextTrackList.h"
53 #include "TimeRanges.h"
54 #include "VideoTrack.h"
55 #include "VideoTrackList.h"
56 #include <runtime/Uint8Array.h>
57 #include <wtf/text/CString.h>
58 #include <wtf/text/WTFString.h>
59
60 namespace WebCore {
61
62 URLRegistry* MediaSource::s_registry = 0;
63
64 void MediaSource::setRegistry(URLRegistry* registry)
65 {
66     ASSERT(!s_registry);
67     s_registry = registry;
68 }
69
70 Ref<MediaSource> MediaSource::create(ScriptExecutionContext& context)
71 {
72     Ref<MediaSource> mediaSource(adoptRef(*new MediaSource(context)));
73     mediaSource->suspendIfNeeded();
74     return mediaSource;
75 }
76
77 MediaSource::MediaSource(ScriptExecutionContext& context)
78     : ActiveDOMObject(&context)
79     , m_mediaElement(nullptr)
80     , m_duration(MediaTime::invalidTime())
81     , m_pendingSeekTime(MediaTime::invalidTime())
82     , m_readyState(closedKeyword())
83     , m_asyncEventQueue(*this)
84 {
85     LOG(MediaSource, "MediaSource::MediaSource %p", this);
86     m_sourceBuffers = SourceBufferList::create(scriptExecutionContext());
87     m_activeSourceBuffers = SourceBufferList::create(scriptExecutionContext());
88 }
89
90 MediaSource::~MediaSource()
91 {
92     LOG(MediaSource, "MediaSource::~MediaSource %p", this);
93     ASSERT(isClosed());
94 }
95
96 const AtomicString& MediaSource::openKeyword()
97 {
98     DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, open, ("open", AtomicString::ConstructFromLiteral));
99     return open;
100 }
101
102 const AtomicString& MediaSource::closedKeyword()
103 {
104     DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, closed, ("closed", AtomicString::ConstructFromLiteral));
105     return closed;
106 }
107
108 const AtomicString& MediaSource::endedKeyword()
109 {
110     DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, ended, ("ended", AtomicString::ConstructFromLiteral));
111     return ended;
112 }
113
114 void MediaSource::setPrivateAndOpen(Ref<MediaSourcePrivate>&& mediaSourcePrivate)
115 {
116     ASSERT(!m_private);
117     ASSERT(m_mediaElement);
118     m_private = WTFMove(mediaSourcePrivate);
119     setReadyState(openKeyword());
120 }
121
122 void MediaSource::addedToRegistry()
123 {
124     setPendingActivity(this);
125 }
126
127 void MediaSource::removedFromRegistry()
128 {
129     unsetPendingActivity(this);
130 }
131
132 MediaTime MediaSource::duration() const
133 {
134     return m_duration;
135 }
136
137 MediaTime MediaSource::currentTime() const
138 {
139     return m_mediaElement ? m_mediaElement->currentMediaTime() : MediaTime::zeroTime();
140 }
141
142 std::unique_ptr<PlatformTimeRanges> MediaSource::buffered() const
143 {
144     // Implements MediaSource algorithm for HTMLMediaElement.buffered.
145     // https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#htmlmediaelement-extensions
146     Vector<PlatformTimeRanges> activeRanges = this->activeRanges();
147
148     // 1. If activeSourceBuffers.length equals 0 then return an empty TimeRanges object and abort these steps.
149     if (activeRanges.isEmpty())
150         return std::make_unique<PlatformTimeRanges>();
151
152     // 2. Let active ranges be the ranges returned by buffered for each SourceBuffer object in activeSourceBuffers.
153     // 3. Let highest end time be the largest range end time in the active ranges.
154     MediaTime highestEndTime = MediaTime::zeroTime();
155     for (auto& ranges : activeRanges) {
156         unsigned length = ranges.length();
157         if (length)
158             highestEndTime = std::max(highestEndTime, ranges.end(length - 1));
159     }
160
161     // Return an empty range if all ranges are empty.
162     if (!highestEndTime)
163         return std::make_unique<PlatformTimeRanges>();
164
165     // 4. Let intersection ranges equal a TimeRange object containing a single range from 0 to highest end time.
166     PlatformTimeRanges intersectionRanges(MediaTime::zeroTime(), highestEndTime);
167
168     // 5. For each SourceBuffer object in activeSourceBuffers run the following steps:
169     bool ended = readyState() == endedKeyword();
170     for (auto& sourceRanges : activeRanges) {
171         // 5.1 Let source ranges equal the ranges returned by the buffered attribute on the current SourceBuffer.
172         // 5.2 If readyState is "ended", then set the end time on the last range in source ranges to highest end time.
173         if (ended && sourceRanges.length())
174             sourceRanges.add(sourceRanges.start(sourceRanges.length() - 1), highestEndTime);
175
176         // 5.3 Let new intersection ranges equal the the intersection between the intersection ranges and the source ranges.
177         // 5.4 Replace the ranges in intersection ranges with the new intersection ranges.
178         intersectionRanges.intersectWith(sourceRanges);
179     }
180
181     return std::make_unique<PlatformTimeRanges>(intersectionRanges);
182 }
183
184 void MediaSource::seekToTime(const MediaTime& time)
185 {
186     // 2.4.3 Seeking
187     // https://dvcs.w3.org/hg/html-media/raw-file/tip/media-source/media-source.html#mediasource-seeking
188
189     m_pendingSeekTime = time;
190
191     // Run the following steps as part of the "Wait until the user agent has established whether or not the
192     // media data for the new playback position is available, and, if it is, until it has decoded enough data
193     // to play back that position" step of the seek algorithm:
194     // 1. The media element looks for media segments containing the new playback position in each SourceBuffer
195     // object in activeSourceBuffers.
196     for (auto& sourceBuffer : *m_activeSourceBuffers) {
197         // ↳ If one or more of the objects in activeSourceBuffers is missing media segments for the new
198         // playback position
199         if (!sourceBuffer->buffered()->ranges().contain(time)) {
200             // 1.1 Set the HTMLMediaElement.readyState attribute to HAVE_METADATA.
201             m_private->setReadyState(MediaPlayer::HaveMetadata);
202
203             // 1.2 The media element waits until an appendBuffer() or an appendStream() call causes the coded
204             // frame processing algorithm to set the HTMLMediaElement.readyState attribute to a value greater
205             // than HAVE_METADATA.
206             LOG(MediaSource, "MediaSource::seekToTime(%p) - waitForSeekCompleted()", this);
207             m_private->waitForSeekCompleted();
208             return;
209         }
210         // ↳ Otherwise
211         // Continue
212     }
213
214     completeSeek();
215 }
216
217 void MediaSource::completeSeek()
218 {
219     // 2.4.3 Seeking, ctd.
220     // https://dvcs.w3.org/hg/html-media/raw-file/tip/media-source/media-source.html#mediasource-seeking
221
222     ASSERT(m_pendingSeekTime.isValid());
223
224     // 2. The media element resets all decoders and initializes each one with data from the appropriate
225     // initialization segment.
226     // 3. The media element feeds coded frames from the active track buffers into the decoders starting
227     // with the closest random access point before the new playback position.
228     for (auto& sourceBuffer : *m_activeSourceBuffers)
229         sourceBuffer->seekToTime(m_pendingSeekTime);
230
231     // 4. Resume the seek algorithm at the "Await a stable state" step.
232     m_private->seekCompleted();
233
234     m_pendingSeekTime = MediaTime::invalidTime();
235     monitorSourceBuffers();
236 }
237
238 void MediaSource::monitorSourceBuffers()
239 {
240     // 2.4.4 SourceBuffer Monitoring
241     // https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#buffer-monitoring
242
243     // Note, the behavior if activeSourceBuffers is empty is undefined.
244     if (!m_activeSourceBuffers) {
245         m_private->setReadyState(MediaPlayer::HaveNothing);
246         return;
247     }
248
249     // http://w3c.github.io/media-source/#buffer-monitoring, change from 11 December 2014
250     // ↳ If the the HTMLMediaElement.readyState attribute equals HAVE_NOTHING:
251     if (mediaElement()->readyState() == HTMLMediaElement::HAVE_NOTHING) {
252         // 1. Abort these steps.
253         return;
254     }
255
256     // ↳ If buffered for all objects in activeSourceBuffers do not contain TimeRanges for the current
257     // playback position:
258     auto begin = m_activeSourceBuffers->begin();
259     auto end = m_activeSourceBuffers->end();
260     if (std::all_of(begin, end, [](RefPtr<SourceBuffer>& sourceBuffer) {
261         return !sourceBuffer->hasCurrentTime();
262     })) {
263         // 1. Set the HTMLMediaElement.readyState attribute to HAVE_METADATA.
264         // 2. If this is the first transition to HAVE_METADATA, then queue a task to fire a simple event
265         // named loadedmetadata at the media element.
266         m_private->setReadyState(MediaPlayer::HaveMetadata);
267
268         // 3. Abort these steps.
269         return;
270     }
271
272     // ↳ If buffered for all objects in activeSourceBuffers contain TimeRanges that include the current
273     // playback position and enough data to ensure uninterrupted playback:
274     if (std::all_of(begin, end, [](RefPtr<SourceBuffer>& sourceBuffer) {
275         return sourceBuffer->hasFutureTime() && sourceBuffer->canPlayThrough();
276     })) {
277         // 1. Set the HTMLMediaElement.readyState attribute to HAVE_ENOUGH_DATA.
278         // 2. Queue a task to fire a simple event named canplaythrough at the media element.
279         // 3. Playback may resume at this point if it was previously suspended by a transition to HAVE_CURRENT_DATA.
280         m_private->setReadyState(MediaPlayer::HaveEnoughData);
281
282         if (m_pendingSeekTime.isValid())
283             completeSeek();
284
285         // 4. Abort these steps.
286         return;
287     }
288
289     // ↳ If buffered for all objects in activeSourceBuffers contain a TimeRange that includes
290     // the current playback position and some time beyond the current playback position, then run the following steps:
291     if (std::all_of(begin, end, [](RefPtr<SourceBuffer>& sourceBuffer) {
292         return sourceBuffer->hasFutureTime();
293     })) {
294         // 1. Set the HTMLMediaElement.readyState attribute to HAVE_FUTURE_DATA.
295         // 2. If the previous value of HTMLMediaElement.readyState was less than HAVE_FUTURE_DATA, then queue a task to fire a simple event named canplay at the media element.
296         // 3. Playback may resume at this point if it was previously suspended by a transition to HAVE_CURRENT_DATA.
297         m_private->setReadyState(MediaPlayer::HaveFutureData);
298
299         if (m_pendingSeekTime.isValid())
300             completeSeek();
301
302         // 4. Abort these steps.
303         return;
304     }
305
306     // ↳ If buffered for at least one object in activeSourceBuffers contains a TimeRange that ends
307     // at the current playback position and does not have a range covering the time immediately
308     // after the current position:
309     // NOTE: Logically, !(all objects do not contain currentTime) == (some objects contain current time)
310
311     // 1. Set the HTMLMediaElement.readyState attribute to HAVE_CURRENT_DATA.
312     // 2. If this is the first transition to HAVE_CURRENT_DATA, then queue a task to fire a simple
313     // event named loadeddata at the media element.
314     // 3. Playback is suspended at this point since the media element doesn't have enough data to
315     // advance the media timeline.
316     m_private->setReadyState(MediaPlayer::HaveCurrentData);
317
318     if (m_pendingSeekTime.isValid())
319         completeSeek();
320
321     // 4. Abort these steps.
322 }
323
324 void MediaSource::setDuration(double duration, ExceptionCode& ec)
325 {
326     // 2.1 Attributes - Duration
327     // https://dvcs.w3.org/hg/html-media/raw-file/tip/media-source/media-source.html#attributes
328
329     // On setting, run the following steps:
330     // 1. If the value being set is negative or NaN then throw an INVALID_ACCESS_ERR exception and abort these steps.
331     if (duration < 0.0 || std::isnan(duration)) {
332         ec = INVALID_ACCESS_ERR;
333         return;
334     }
335
336     // 2. If the readyState attribute is not "open" then throw an INVALID_STATE_ERR exception and abort these steps.
337     if (!isOpen()) {
338         ec = INVALID_STATE_ERR;
339         return;
340     }
341
342     // 3. If the updating attribute equals true on any SourceBuffer in sourceBuffers, then throw an INVALID_STATE_ERR
343     // exception and abort these steps.
344     for (auto& sourceBuffer : *m_sourceBuffers) {
345         if (sourceBuffer->updating()) {
346             ec = INVALID_STATE_ERR;
347             return;
348         }
349     }
350
351     // 4. Run the duration change algorithm with new duration set to the value being assigned to this attribute.
352     setDurationInternal(MediaTime::createWithDouble(duration));
353 }
354
355 void MediaSource::setDurationInternal(const MediaTime& duration)
356 {
357     // Duration Change Algorithm
358     // https://dvcs.w3.org/hg/html-media/raw-file/tip/media-source/media-source.html#duration-change-algorithm
359
360     // 1. If the current value of duration is equal to new duration, then return.
361     if (duration == m_duration)
362         return;
363
364     // 2. Set old duration to the current value of duration.
365     MediaTime oldDuration = m_duration;
366
367     // 3. Update duration to new duration.
368     m_duration = duration;
369
370     // 4. If the new duration is less than old duration, then call remove(new duration, old duration)
371     // on all objects in sourceBuffers.
372     if (oldDuration.isValid() && duration < oldDuration) {
373         for (auto& sourceBuffer : *m_sourceBuffers)
374             sourceBuffer->rangeRemoval(duration, oldDuration);
375     }
376
377     // 5. If a user agent is unable to partially render audio frames or text cues that start before and end after the
378     // duration, then run the following steps:
379     // 5.1 Update new duration to the highest end time reported by the buffered attribute across all SourceBuffer objects
380     // in sourceBuffers.
381     // 5.2 Update duration to new duration.
382     // NOTE: Assume UA is able to partially render audio frames.
383
384     // 6. Update the media controller duration to new duration and run the HTMLMediaElement duration change algorithm.
385     LOG(MediaSource, "MediaSource::setDurationInternal(%p) - duration(%g)", this, duration.toDouble());
386     m_private->durationChanged();
387 }
388
389 void MediaSource::setReadyState(const AtomicString& state)
390 {
391     ASSERT(state == openKeyword() || state == closedKeyword() || state == endedKeyword());
392
393     AtomicString oldState = readyState();
394     LOG(MediaSource, "MediaSource::setReadyState(%p) : %s -> %s", this, oldState.string().ascii().data(), state.string().ascii().data());
395
396     if (state == closedKeyword()) {
397         m_private = nullptr;
398         m_mediaElement = nullptr;
399         m_duration = MediaTime::invalidTime();
400     }
401
402     if (oldState == state)
403         return;
404
405     m_readyState = state;
406
407     onReadyStateChange(oldState, state);
408 }
409
410 static bool SourceBufferIsUpdating(RefPtr<SourceBuffer>& sourceBuffer)
411 {
412     return sourceBuffer->updating();
413 }
414
415 void MediaSource::endOfStream(ExceptionCode& ec)
416 {
417     endOfStream(emptyAtom, ec);
418 }
419
420 void MediaSource::endOfStream(const AtomicString& error, ExceptionCode& ec)
421 {
422     // 2.2 https://dvcs.w3.org/hg/html-media/raw-file/tip/media-source/media-source.html#widl-MediaSource-endOfStream-void-EndOfStreamError-error
423     // 1. If the readyState attribute is not in the "open" state then throw an
424     // INVALID_STATE_ERR exception and abort these steps.
425     if (!isOpen()) {
426         ec = INVALID_STATE_ERR;
427         return;
428     }
429
430     // 2. If the updating attribute equals true on any SourceBuffer in sourceBuffers, then throw an
431     // INVALID_STATE_ERR exception and abort these steps.
432     if (std::any_of(m_sourceBuffers->begin(), m_sourceBuffers->end(), SourceBufferIsUpdating)) {
433         ec = INVALID_STATE_ERR;
434         return;
435     }
436
437     // 3. Run the end of stream algorithm with the error parameter set to error.
438     streamEndedWithError(error, ec);
439 }
440
441 void MediaSource::streamEndedWithError(const AtomicString& error, ExceptionCode& ec)
442 {
443     DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, network, ("network", AtomicString::ConstructFromLiteral));
444     DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, decode, ("decode", AtomicString::ConstructFromLiteral));
445
446     LOG(MediaSource, "MediaSource::streamEndedWithError(%p) : %s", this, error.string().ascii().data());
447
448     // 2.4.7 https://dvcs.w3.org/hg/html-media/raw-file/tip/media-source/media-source.html#end-of-stream-algorithm
449
450     // 1. Change the readyState attribute value to "ended".
451     // 2. Queue a task to fire a simple event named sourceended at the MediaSource.
452     setReadyState(endedKeyword());
453
454     // 3.
455     if (error.isEmpty()) {
456         // ↳ If error is not set, is null, or is an empty string
457         // 1. Run the duration change algorithm with new duration set to the highest end time reported by
458         // the buffered attribute across all SourceBuffer objects in sourceBuffers.
459         MediaTime maxEndTime;
460         for (auto& sourceBuffer : *m_sourceBuffers) {
461             if (auto length = sourceBuffer->buffered()->length())
462                 maxEndTime = std::max(sourceBuffer->buffered()->ranges().end(length - 1), maxEndTime);
463         }
464         setDurationInternal(maxEndTime);
465
466         // 2. Notify the media element that it now has all of the media data.
467         m_private->markEndOfStream(MediaSourcePrivate::EosNoError);
468     }
469
470     if (error == network) {
471         // ↳ If error is set to "network"
472         ASSERT(m_mediaElement);
473         if (m_mediaElement->readyState() == HTMLMediaElement::HAVE_NOTHING) {
474             //  ↳ If the HTMLMediaElement.readyState attribute equals HAVE_NOTHING
475             //    Run the "If the media data cannot be fetched at all, due to network errors, causing
476             //    the user agent to give up trying to fetch the resource" steps of the resource fetch algorithm.
477             //    NOTE: This step is handled by HTMLMediaElement::mediaLoadingFailed().
478             m_mediaElement->mediaLoadingFailed(MediaPlayer::NetworkError);
479         } else {
480             //  ↳ If the HTMLMediaElement.readyState attribute is greater than HAVE_NOTHING
481             //    Run the "If the connection is interrupted after some media data has been received, causing the
482             //    user agent to give up trying to fetch the resource" steps of the resource fetch algorithm.
483             //    NOTE: This step is handled by HTMLMediaElement::mediaLoadingFailedFatally().
484             m_mediaElement->mediaLoadingFailedFatally(MediaPlayer::NetworkError);
485         }
486     } else if (error == decode) {
487         // ↳ If error is set to "decode"
488         ASSERT(m_mediaElement);
489         if (m_mediaElement->readyState() == HTMLMediaElement::HAVE_NOTHING) {
490             //  ↳ If the HTMLMediaElement.readyState attribute equals HAVE_NOTHING
491             //    Run the "If the media data can be fetched but is found by inspection to be in an unsupported
492             //    format, or can otherwise not be rendered at all" steps of the resource fetch algorithm.
493             //    NOTE: This step is handled by HTMLMediaElement::mediaLoadingFailed().
494             m_mediaElement->mediaLoadingFailed(MediaPlayer::FormatError);
495         } else {
496             //  ↳ If the HTMLMediaElement.readyState attribute is greater than HAVE_NOTHING
497             //    Run the media data is corrupted steps of the resource fetch algorithm.
498             //    NOTE: This step is handled by HTMLMediaElement::mediaLoadingFailedFatally().
499             m_mediaElement->mediaLoadingFailedFatally(MediaPlayer::DecodeError);
500         }
501     } else if (!error.isEmpty()) {
502         // ↳ Otherwise
503         //   Throw an INVALID_ACCESS_ERR exception.
504         ec = INVALID_ACCESS_ERR;
505     }
506 }
507
508 SourceBuffer* MediaSource::addSourceBuffer(const String& type, ExceptionCode& ec)
509 {
510     LOG(MediaSource, "MediaSource::addSourceBuffer(%s) %p", type.ascii().data(), this);
511
512     // 2.2 http://www.w3.org/TR/media-source/#widl-MediaSource-addSourceBuffer-SourceBuffer-DOMString-type
513     // When this method is invoked, the user agent must run the following steps:
514
515     // 1. If type is null or an empty then throw an INVALID_ACCESS_ERR exception and
516     // abort these steps.
517     if (type.isNull() || type.isEmpty()) {
518         ec = INVALID_ACCESS_ERR;
519         return nullptr;
520     }
521
522     // 2. If type contains a MIME type that is not supported ..., then throw a
523     // NOT_SUPPORTED_ERR exception and abort these steps.
524     if (!isTypeSupported(type)) {
525         ec = NOT_SUPPORTED_ERR;
526         return nullptr;
527     }
528
529     // 4. If the readyState attribute is not in the "open" state then throw an
530     // INVALID_STATE_ERR exception and abort these steps.
531     if (!isOpen()) {
532         ec = INVALID_STATE_ERR;
533         return nullptr;
534     }
535
536     // 5. Create a new SourceBuffer object and associated resources.
537     ContentType contentType(type);
538     RefPtr<SourceBufferPrivate> sourceBufferPrivate = createSourceBufferPrivate(contentType, ec);
539
540     if (!sourceBufferPrivate) {
541         ASSERT(ec == NOT_SUPPORTED_ERR || ec == QUOTA_EXCEEDED_ERR);
542         // 2. If type contains a MIME type that is not supported ..., then throw a NOT_SUPPORTED_ERR exception and abort these steps.
543         // 3. If the user agent can't handle any more SourceBuffer objects then throw a QUOTA_EXCEEDED_ERR exception and abort these steps
544         return nullptr;
545     }
546
547     RefPtr<SourceBuffer> buffer = SourceBuffer::create(sourceBufferPrivate.releaseNonNull(), this);
548
549     // 6. Set the generate timestamps flag on the new object to the value in the "Generate Timestamps Flag"
550     // column of the byte stream format registry [MSE-REGISTRY] entry that is associated with type.
551     // NOTE: In the current byte stream format registry <http://www.w3.org/2013/12/byte-stream-format-registry/>
552     // only the "MPEG Audio Byte Stream Format" has the "Generate Timestamps Flag" value set.
553     bool shouldGenerateTimestamps = contentType.type() == "audio/aac" || contentType.type() == "audio/mpeg";
554     buffer->setShouldGenerateTimestamps(shouldGenerateTimestamps);
555
556     // 7. If the generate timestamps flag equals true:
557     // ↳ Set the mode attribute on the new object to "sequence".
558     // Otherwise:
559     // ↳ Set the mode attribute on the new object to "segments".
560     buffer->setMode(shouldGenerateTimestamps ? SourceBuffer::sequenceKeyword() : SourceBuffer::segmentsKeyword(), IGNORE_EXCEPTION);
561
562     // 8. Add the new object to sourceBuffers and fire a addsourcebuffer on that object.
563     m_sourceBuffers->add(buffer);
564     regenerateActiveSourceBuffers();
565
566     // 9. Return the new object to the caller.
567     return buffer.get();
568 }
569
570 void MediaSource::removeSourceBuffer(SourceBuffer* buffer, ExceptionCode& ec)
571 {
572     LOG(MediaSource, "MediaSource::removeSourceBuffer() %p", this);
573     RefPtr<SourceBuffer> protect(buffer);
574
575     // 2.2 https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#widl-MediaSource-removeSourceBuffer-void-SourceBuffer-sourceBuffer
576     // 1. If sourceBuffer is null then throw an INVALID_ACCESS_ERR exception and
577     // abort these steps.
578     if (!buffer) {
579         ec = INVALID_ACCESS_ERR;
580         return;
581     }
582
583     // 2. If sourceBuffer specifies an object that is not in sourceBuffers then
584     // throw a NOT_FOUND_ERR exception and abort these steps.
585     if (!m_sourceBuffers->length() || !m_sourceBuffers->contains(buffer)) {
586         ec = NOT_FOUND_ERR;
587         return;
588     }
589
590     // 3. If the sourceBuffer.updating attribute equals true, then run the following steps: ...
591     buffer->abortIfUpdating();
592
593     // 4. Let SourceBuffer audioTracks list equal the AudioTrackList object returned by sourceBuffer.audioTracks.
594     RefPtr<AudioTrackList> audioTracks = buffer->audioTracks();
595
596     // 5. If the SourceBuffer audioTracks list is not empty, then run the following steps:
597     if (audioTracks->length()) {
598         // 5.1 Let HTMLMediaElement audioTracks list equal the AudioTrackList object returned by the audioTracks
599         // attribute on the HTMLMediaElement.
600         // 5.2 Let the removed enabled audio track flag equal false.
601         bool removedEnabledAudioTrack = false;
602
603         // 5.3 For each AudioTrack object in the SourceBuffer audioTracks list, run the following steps:
604         while (audioTracks->length()) {
605             AudioTrack* track = audioTracks->lastItem();
606
607             // 5.3.1 Set the sourceBuffer attribute on the AudioTrack object to null.
608             track->setSourceBuffer(nullptr);
609
610             // 5.3.2 If the enabled attribute on the AudioTrack object is true, then set the removed enabled
611             // audio track flag to true.
612             if (track->enabled())
613                 removedEnabledAudioTrack = true;
614
615             // 5.3.3 Remove the AudioTrack object from the HTMLMediaElement audioTracks list.
616             // 5.3.4 Queue a task to fire a trusted event named removetrack, that does not bubble and is not
617             // cancelable, and that uses the TrackEvent interface, at the HTMLMediaElement audioTracks list.
618             if (mediaElement())
619                 mediaElement()->removeAudioTrack(track);
620
621             // 5.3.5 Remove the AudioTrack object from the SourceBuffer audioTracks list.
622             // 5.3.6 Queue a task to fire a trusted event named removetrack, that does not bubble and is not
623             // cancelable, and that uses the TrackEvent interface, at the SourceBuffer audioTracks list.
624             audioTracks->remove(track);
625         }
626
627         // 5.4 If the removed enabled audio track flag equals true, then queue a task to fire a simple event
628         // named change at the HTMLMediaElement audioTracks list.
629         if (removedEnabledAudioTrack)
630             mediaElement()->audioTracks()->scheduleChangeEvent();
631     }
632
633     // 6. Let SourceBuffer videoTracks list equal the VideoTrackList object returned by sourceBuffer.videoTracks.
634     RefPtr<VideoTrackList> videoTracks = buffer->videoTracks();
635
636     // 7. If the SourceBuffer videoTracks list is not empty, then run the following steps:
637     if (videoTracks->length()) {
638         // 7.1 Let HTMLMediaElement videoTracks list equal the VideoTrackList object returned by the videoTracks
639         // attribute on the HTMLMediaElement.
640         // 7.2 Let the removed selected video track flag equal false.
641         bool removedSelectedVideoTrack = false;
642
643         // 7.3 For each VideoTrack object in the SourceBuffer videoTracks list, run the following steps:
644         while (videoTracks->length()) {
645             VideoTrack* track = videoTracks->lastItem();
646
647             // 7.3.1 Set the sourceBuffer attribute on the VideoTrack object to null.
648             track->setSourceBuffer(nullptr);
649
650             // 7.3.2 If the selected attribute on the VideoTrack object is true, then set the removed selected
651             // video track flag to true.
652             if (track->selected())
653                 removedSelectedVideoTrack = true;
654
655             // 7.3.3 Remove the VideoTrack object from the HTMLMediaElement videoTracks list.
656             // 7.3.4 Queue a task to fire a trusted event named removetrack, that does not bubble and is not
657             // cancelable, and that uses the TrackEvent interface, at the HTMLMediaElement videoTracks list.
658             if (mediaElement())
659                 mediaElement()->removeVideoTrack(track);
660
661             // 7.3.5 Remove the VideoTrack object from the SourceBuffer videoTracks list.
662             // 7.3.6 Queue a task to fire a trusted event named removetrack, that does not bubble and is not
663             // cancelable, and that uses the TrackEvent interface, at the SourceBuffer videoTracks list.
664             videoTracks->remove(track);
665         }
666
667         // 7.4 If the removed selected video track flag equals true, then queue a task to fire a simple event
668         // named change at the HTMLMediaElement videoTracks list.
669         if (removedSelectedVideoTrack)
670             mediaElement()->videoTracks()->scheduleChangeEvent();
671     }
672
673     // 8. Let SourceBuffer textTracks list equal the TextTrackList object returned by sourceBuffer.textTracks.
674     RefPtr<TextTrackList> textTracks = buffer->textTracks();
675
676     // 9. If the SourceBuffer textTracks list is not empty, then run the following steps:
677     if (textTracks->length()) {
678         // 9.1 Let HTMLMediaElement textTracks list equal the TextTrackList object returned by the textTracks
679         // attribute on the HTMLMediaElement.
680         // 9.2 Let the removed enabled text track flag equal false.
681         bool removedEnabledTextTrack = false;
682
683         // 9.3 For each TextTrack object in the SourceBuffer textTracks list, run the following steps:
684         while (textTracks->length()) {
685             TextTrack* track = textTracks->lastItem();
686
687             // 9.3.1 Set the sourceBuffer attribute on the TextTrack object to null.
688             track->setSourceBuffer(nullptr);
689
690             // 9.3.2 If the mode attribute on the TextTrack object is set to "showing" or "hidden", then
691             // set the removed enabled text track flag to true.
692             if (track->mode() == TextTrack::showingKeyword() || track->mode() == TextTrack::hiddenKeyword())
693                 removedEnabledTextTrack = true;
694
695             // 9.3.3 Remove the TextTrack object from the HTMLMediaElement textTracks list.
696             // 9.3.4 Queue a task to fire a trusted event named removetrack, that does not bubble and is not
697             // cancelable, and that uses the TrackEvent interface, at the HTMLMediaElement textTracks list.
698             if (mediaElement())
699                 mediaElement()->removeTextTrack(track);
700
701             // 9.3.5 Remove the TextTrack object from the SourceBuffer textTracks list.
702             // 9.3.6 Queue a task to fire a trusted event named removetrack, that does not bubble and is not
703             // cancelable, and that uses the TrackEvent interface, at the SourceBuffer textTracks list.
704             textTracks->remove(track);
705         }
706         
707         // 9.4 If the removed enabled text track flag equals true, then queue a task to fire a simple event
708         // named change at the HTMLMediaElement textTracks list.
709         if (removedEnabledTextTrack)
710             mediaElement()->textTracks()->scheduleChangeEvent();
711     }
712     
713     
714     // 10. If sourceBuffer is in activeSourceBuffers, then remove sourceBuffer from activeSourceBuffers ...
715     m_activeSourceBuffers->remove(buffer);
716     
717     // 11. Remove sourceBuffer from sourceBuffers and fire a removesourcebuffer event
718     // on that object.
719     m_sourceBuffers->remove(buffer);
720     
721     // 12. Destroy all resources for sourceBuffer.
722     buffer->removedFromMediaSource();
723 }
724
725 bool MediaSource::isTypeSupported(const String& type)
726 {
727     LOG(MediaSource, "MediaSource::isTypeSupported(%s)", type.ascii().data());
728
729     // Section 2.2 isTypeSupported() method steps.
730     // https://dvcs.w3.org/hg/html-media/raw-file/tip/media-source/media-source.html#widl-MediaSource-isTypeSupported-boolean-DOMString-type
731     // 1. If type is an empty string, then return false.
732     if (type.isNull() || type.isEmpty())
733         return false;
734
735     ContentType contentType(type.lower());
736     String codecs = contentType.parameter("codecs");
737
738     // 2. If type does not contain a valid MIME type string, then return false.
739     if (contentType.type().isEmpty())
740         return false;
741
742     // 3. If type contains a media type or media subtype that the MediaSource does not support, then return false.
743     // 4. If type contains at a codec that the MediaSource does not support, then return false.
744     // 5. If the MediaSource does not support the specified combination of media type, media subtype, and codecs then return false.
745     // 6. Return true.
746     MediaEngineSupportParameters parameters;
747     parameters.type = contentType.type();
748     parameters.codecs = codecs;
749     parameters.isMediaSource = true;
750     MediaPlayer::SupportsType supported = MediaPlayer::supportsType(parameters, 0);
751
752     if (codecs.isEmpty())
753         return supported != MediaPlayer::IsNotSupported;
754
755     return supported == MediaPlayer::IsSupported;
756 }
757
758 bool MediaSource::isOpen() const
759 {
760     return readyState() == openKeyword();
761 }
762
763 bool MediaSource::isClosed() const
764 {
765     return readyState() == closedKeyword();
766 }
767
768 bool MediaSource::isEnded() const
769 {
770     return readyState() == endedKeyword();
771 }
772
773 void MediaSource::close()
774 {
775     setReadyState(closedKeyword());
776 }
777
778 void MediaSource::sourceBufferDidChangeAcitveState(SourceBuffer*, bool)
779 {
780     regenerateActiveSourceBuffers();
781 }
782
783 bool MediaSource::attachToElement(HTMLMediaElement* element)
784 {
785     if (m_mediaElement)
786         return false;
787
788     ASSERT(isClosed());
789
790     m_mediaElement = element;
791     return true;
792 }
793
794 void MediaSource::openIfInEndedState()
795 {
796     if (m_readyState != endedKeyword())
797         return;
798
799     setReadyState(openKeyword());
800     m_private->unmarkEndOfStream();
801 }
802
803 bool MediaSource::hasPendingActivity() const
804 {
805     return m_private || m_asyncEventQueue.hasPendingEvents()
806         || ActiveDOMObject::hasPendingActivity();
807 }
808
809 void MediaSource::stop()
810 {
811     m_asyncEventQueue.close();
812     if (!isClosed())
813         setReadyState(closedKeyword());
814     m_private = nullptr;
815 }
816
817 bool MediaSource::canSuspendForDocumentSuspension() const
818 {
819     return isClosed() && !m_asyncEventQueue.hasPendingEvents();
820 }
821
822 const char* MediaSource::activeDOMObjectName() const
823 {
824     return "MediaSource";
825 }
826
827 void MediaSource::onReadyStateChange(const AtomicString& oldState, const AtomicString& newState)
828 {
829     if (isOpen()) {
830         scheduleEvent(eventNames().sourceopenEvent);
831         return;
832     }
833
834     if (oldState == openKeyword() && newState == endedKeyword()) {
835         scheduleEvent(eventNames().sourceendedEvent);
836         return;
837     }
838
839     ASSERT(isClosed());
840
841     m_activeSourceBuffers->clear();
842
843     // Clear SourceBuffer references to this object.
844     for (auto& buffer : *m_sourceBuffers)
845         buffer->removedFromMediaSource();
846     m_sourceBuffers->clear();
847     
848     scheduleEvent(eventNames().sourcecloseEvent);
849 }
850
851 Vector<PlatformTimeRanges> MediaSource::activeRanges() const
852 {
853     Vector<PlatformTimeRanges> activeRanges;
854     for (auto& sourceBuffer : *m_activeSourceBuffers)
855         activeRanges.append(sourceBuffer->buffered()->ranges());
856     return activeRanges;
857 }
858
859 RefPtr<SourceBufferPrivate> MediaSource::createSourceBufferPrivate(const ContentType& type, ExceptionCode& ec)
860 {
861     RefPtr<SourceBufferPrivate> sourceBufferPrivate;
862     switch (m_private->addSourceBuffer(type, sourceBufferPrivate)) {
863     case MediaSourcePrivate::Ok: {
864         return sourceBufferPrivate;
865     }
866     case MediaSourcePrivate::NotSupported:
867         // 2.2 https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#widl-MediaSource-addSourceBuffer-SourceBuffer-DOMString-type
868         // Step 2: If type contains a MIME type ... that is not supported with the types
869         // specified for the other SourceBuffer objects in sourceBuffers, then throw
870         // a NOT_SUPPORTED_ERR exception and abort these steps.
871         ec = NOT_SUPPORTED_ERR;
872         return nullptr;
873     case MediaSourcePrivate::ReachedIdLimit:
874         // 2.2 https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#widl-MediaSource-addSourceBuffer-SourceBuffer-DOMString-type
875         // Step 3: If the user agent can't handle any more SourceBuffer objects then throw
876         // a QUOTA_EXCEEDED_ERR exception and abort these steps.
877         ec = QUOTA_EXCEEDED_ERR;
878         return nullptr;
879     }
880
881     ASSERT_NOT_REACHED();
882     return nullptr;
883 }
884
885 void MediaSource::scheduleEvent(const AtomicString& eventName)
886 {
887     RefPtr<Event> event = Event::create(eventName, false, false);
888     event->setTarget(this);
889
890     m_asyncEventQueue.enqueueEvent(event.release());
891 }
892
893 ScriptExecutionContext* MediaSource::scriptExecutionContext() const
894 {
895     return ActiveDOMObject::scriptExecutionContext();
896 }
897
898 EventTargetInterface MediaSource::eventTargetInterface() const
899 {
900     return MediaSourceEventTargetInterfaceType;
901 }
902
903 URLRegistry& MediaSource::registry() const
904 {
905     return MediaSourceRegistry::registry();
906 }
907
908 void MediaSource::regenerateActiveSourceBuffers()
909 {
910     Vector<RefPtr<SourceBuffer>> newList;
911     for (auto& sourceBuffer : *m_sourceBuffers) {
912         if (sourceBuffer->active())
913             newList.append(sourceBuffer);
914     }
915     m_activeSourceBuffers->swap(newList);
916 }
917
918 }
919
920 #endif