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