#include "config.h"
#if ENABLE(VIDEO_TRACK)
#include "TextTrack.h"
#include "Event.h"
#include "HTMLMediaElement.h"
#include "SourceBuffer.h"
#include "TextTrackCueList.h"
#include "TextTrackList.h"
#include "VTTRegion.h"
#include "VTTRegionList.h"
namespace WebCore {
static const int invalidTrackIndex = -1;
const AtomicString& TextTrack::subtitlesKeyword()
{
static NeverDestroyed<const AtomicString> subtitles("subtitles", AtomicString::ConstructFromLiteral);
return subtitles;
}
static const AtomicString& captionsKeyword()
{
static NeverDestroyed<const AtomicString> captions("captions", AtomicString::ConstructFromLiteral);
return captions;
}
static const AtomicString& descriptionsKeyword()
{
static NeverDestroyed<const AtomicString> descriptions("descriptions", AtomicString::ConstructFromLiteral);
return descriptions;
}
static const AtomicString& chaptersKeyword()
{
static NeverDestroyed<const AtomicString> chapters("chapters", AtomicString::ConstructFromLiteral);
return chapters;
}
static const AtomicString& metadataKeyword()
{
static NeverDestroyed<const AtomicString> metadata("metadata", AtomicString::ConstructFromLiteral);
return metadata;
}
static const AtomicString& forcedKeyword()
{
static NeverDestroyed<const AtomicString> forced("forced", AtomicString::ConstructFromLiteral);
return forced;
}
TextTrack* TextTrack::captionMenuOffItem()
{
static TextTrack& off = TextTrack::create(0, 0, "off menu item", emptyAtom, emptyAtom, emptyAtom).leakRef();
return &off;
}
TextTrack* TextTrack::captionMenuAutomaticItem()
{
static TextTrack& automatic = TextTrack::create(0, 0, "automatic menu item", emptyAtom, emptyAtom, emptyAtom).leakRef();
return &automatic;
}
TextTrack::TextTrack(ScriptExecutionContext* context, TextTrackClient* client, const AtomicString& kind, const AtomicString& id, const AtomicString& label, const AtomicString& language, TextTrackType type)
: TrackBase(TrackBase::TextTrack, id, label, language)
, m_scriptExecutionContext(context)
, m_client(client)
, m_trackType(type)
, m_trackIndex(invalidTrackIndex)
, m_renderedTrackIndex(invalidTrackIndex)
{
if (kind == captionsKeyword())
m_kind = Kind::Captions;
else if (kind == chaptersKeyword())
m_kind = Kind::Chapters;
else if (kind == descriptionsKeyword())
m_kind = Kind::Descriptions;
else if (kind == forcedKeyword())
m_kind = Kind::Forced;
else if (kind == metadataKeyword())
m_kind = Kind::Metadata;
}
TextTrack::~TextTrack()
{
if (m_cues) {
if (m_client)
m_client->textTrackRemoveCues(this, m_cues.get());
for (size_t i = 0; i < m_cues->length(); ++i)
m_cues->item(i)->setTrack(nullptr);
}
if (m_regions) {
for (size_t i = 0; i < m_regions->length(); ++i)
m_regions->item(i)->setTrack(nullptr);
}
}
bool TextTrack::enabled() const
{
return m_mode != Mode::Disabled;
}
bool TextTrack::isValidKindKeyword(const AtomicString& value)
{
if (value == subtitlesKeyword())
return true;
if (value == captionsKeyword())
return true;
if (value == descriptionsKeyword())
return true;
if (value == chaptersKeyword())
return true;
if (value == metadataKeyword())
return true;
if (value == forcedKeyword())
return true;
return false;
}
const AtomicString& TextTrack::kindKeyword() const
{
switch (m_kind) {
case Kind::Captions:
return captionsKeyword();
case Kind::Chapters:
return chaptersKeyword();
case Kind::Descriptions:
return descriptionsKeyword();
case Kind::Forced:
return forcedKeyword();
case Kind::Metadata:
return metadataKeyword();
case Kind::Subtitles:
return subtitlesKeyword();
}
ASSERT_NOT_REACHED();
return subtitlesKeyword();
}
void TextTrack::setKind(Kind newKind)
{
auto oldKind = m_kind;
m_kind = newKind;
#if ENABLE(MEDIA_SOURCE)
if (m_sourceBuffer)
m_sourceBuffer->textTracks()->scheduleChangeEvent();
if (mediaElement())
mediaElement()->textTracks().scheduleChangeEvent();
#endif
if (m_client && oldKind != m_kind)
m_client->textTrackKindChanged(this);
}
void TextTrack::setKindKeywordIgnoringASCIICase(StringView keyword)
{
if (equalLettersIgnoringASCIICase(keyword, "captions"))
setKind(Kind::Captions);
else if (equalLettersIgnoringASCIICase(keyword, "chapters"))
setKind(Kind::Chapters);
else if (equalLettersIgnoringASCIICase(keyword, "descriptions"))
setKind(Kind::Descriptions);
else if (equalLettersIgnoringASCIICase(keyword, "forced"))
setKind(Kind::Forced);
else if (equalLettersIgnoringASCIICase(keyword, "metadata"))
setKind(Kind::Metadata);
else if (equalLettersIgnoringASCIICase(keyword, "subtitles"))
setKind(Kind::Subtitles);
#if !ENABLE(MEDIA_SOURCE)
else
setKind(Kind::Subtitles);
#endif
}
void TextTrack::setMode(Mode mode)
{
if (m_mode == mode)
return;
if (mode == Mode::Disabled && m_client && m_cues)
m_client->textTrackRemoveCues(this, m_cues.get());
if (mode != Mode::Showing && m_cues) {
for (size_t i = 0; i < m_cues->length(); ++i) {
TextTrackCue* cue = m_cues->item(i);
if (cue->isRenderable())
toVTTCue(cue)->removeDisplayTree();
}
}
m_mode = mode;
if (m_client)
m_client->textTrackModeChanged(this);
}
TextTrackCueList* TextTrack::cues()
{
if (m_mode == Mode::Disabled)
return nullptr;
return &ensureTextTrackCueList();
}
void TextTrack::removeAllCues()
{
if (!m_cues)
return;
if (m_client)
m_client->textTrackRemoveCues(this, m_cues.get());
for (size_t i = 0; i < m_cues->length(); ++i)
m_cues->item(i)->setTrack(nullptr);
m_cues = nullptr;
}
TextTrackCueList* TextTrack::activeCues() const
{
if (!m_cues || m_mode == Mode::Disabled)
return nullptr;
return m_cues->activeCues();
}
void TextTrack::addCue(PassRefPtr<TextTrackCue> prpCue, ExceptionCode& ec)
{
if (!prpCue)
return;
RefPtr<TextTrackCue> cue = prpCue;
if (cue->cueType() == TextTrackCue::Data && m_kind != Kind::Metadata) {
ec = INVALID_NODE_TYPE_ERR;
return;
}
if (!cue->startMediaTime().isValid() || !cue->endMediaTime().isValid() || cue->startMediaTime() < MediaTime::zeroTime() || cue->endMediaTime() < MediaTime::zeroTime())
return;
TextTrack* cueTrack = cue->track();
if (cueTrack && cueTrack != this)
cueTrack->removeCue(cue.get(), ASSERT_NO_EXCEPTION);
cue->setTrack(this);
ensureTextTrackCueList().add(cue);
if (m_client)
m_client->textTrackAddCue(this, cue.get());
}
void TextTrack::removeCue(TextTrackCue* cue, ExceptionCode& ec)
{
if (!cue)
return;
if (cue->track() != this) {
ec = NOT_FOUND_ERR;
return;
}
if (!m_cues || !m_cues->remove(cue)) {
ec = INVALID_STATE_ERR;
return;
}
cue->setTrack(0);
if (m_client)
m_client->textTrackRemoveCue(this, cue);
}
VTTRegionList& TextTrack::ensureVTTRegionList()
{
if (!m_regions)
m_regions = VTTRegionList::create();
return *m_regions;
}
VTTRegionList* TextTrack::regions()
{
if (m_mode == Mode::Disabled)
return nullptr;
return &ensureVTTRegionList();
}
void TextTrack::addRegion(PassRefPtr<VTTRegion> prpRegion)
{
if (!prpRegion)
return;
RefPtr<VTTRegion> region = prpRegion;
VTTRegionList& regionList = ensureVTTRegionList();
TextTrack* regionTrack = region->track();
if (regionTrack && regionTrack != this)
regionTrack->removeRegion(region.get(), ASSERT_NO_EXCEPTION);
VTTRegion* existingRegion = regionList.getRegionById(region->id());
if (existingRegion) {
existingRegion->updateParametersFromRegion(region.get());
return;
}
region->setTrack(this);
regionList.add(region);
}
void TextTrack::removeRegion(VTTRegion* region, ExceptionCode &ec)
{
if (!region)
return;
if (region->track() != this) {
ec = NOT_FOUND_ERR;
return;
}
if (!m_regions || !m_regions->remove(region)) {
ec = INVALID_STATE_ERR;
return;
}
region->setTrack(0);
}
void TextTrack::cueWillChange(TextTrackCue* cue)
{
if (!m_client)
return;
m_client->textTrackRemoveCue(this, cue);
}
void TextTrack::cueDidChange(TextTrackCue* cue)
{
if (!m_client)
return;
ensureTextTrackCueList().updateCueIndex(cue);
m_client->textTrackAddCue(this, cue);
}
int TextTrack::trackIndex()
{
ASSERT(m_mediaElement);
if (m_trackIndex == invalidTrackIndex)
m_trackIndex = m_mediaElement->textTracks().getTrackIndex(*this);
return m_trackIndex;
}
void TextTrack::invalidateTrackIndex()
{
m_trackIndex = invalidTrackIndex;
m_renderedTrackIndex = invalidTrackIndex;
}
bool TextTrack::isRendered()
{
return (m_kind == Kind::Captions || m_kind == Kind::Subtitles || m_kind == Kind::Forced)
&& m_mode == Mode::Showing;
}
TextTrackCueList& TextTrack::ensureTextTrackCueList()
{
if (!m_cues)
m_cues = TextTrackCueList::create();
return *m_cues;
}
int TextTrack::trackIndexRelativeToRenderedTracks()
{
ASSERT(m_mediaElement);
if (m_renderedTrackIndex == invalidTrackIndex)
m_renderedTrackIndex = m_mediaElement->textTracks().getTrackIndexRelativeToRenderedTracks(*this);
return m_renderedTrackIndex;
}
bool TextTrack::hasCue(TextTrackCue* cue, TextTrackCue::CueMatchRules match)
{
if (cue->startMediaTime() < MediaTime::zeroTime() || cue->endMediaTime() < MediaTime::zeroTime())
return false;
if (!m_cues || !m_cues->length())
return false;
size_t searchStart = 0;
size_t searchEnd = m_cues->length();
while (1) {
ASSERT(searchStart <= m_cues->length());
ASSERT(searchEnd <= m_cues->length());
TextTrackCue* existingCue;
if (searchStart == searchEnd) {
if (!searchStart)
return false;
while (searchStart >= 2 && cue->hasEquivalentStartTime(*m_cues->item(searchStart - 2)))
--searchStart;
bool firstCompare = true;
while (1) {
if (!firstCompare)
++searchStart;
firstCompare = false;
if (searchStart > m_cues->length())
return false;
existingCue = m_cues->item(searchStart - 1);
if (!existingCue)
return false;
if (cue->startMediaTime() > (existingCue->startMediaTime() + startTimeVariance()))
return false;
if (existingCue->isEqual(*cue, match))
return true;
}
}
size_t index = (searchStart + searchEnd) / 2;
existingCue = m_cues->item(index);
if ((cue->startMediaTime() + startTimeVariance()) < existingCue->startMediaTime() || (match != TextTrackCue::IgnoreDuration && cue->hasEquivalentStartTime(*existingCue) && cue->endMediaTime() > existingCue->endMediaTime()))
searchEnd = index;
else
searchStart = index + 1;
}
ASSERT_NOT_REACHED();
return false;
}
bool TextTrack::isMainProgramContent() const
{
return m_kind == Kind::Captions;
}
bool TextTrack::containsOnlyForcedSubtitles() const
{
return m_kind == Kind::Forced;
}
#if ENABLE(MEDIA_SOURCE)
void TextTrack::setLanguage(const AtomicString& language)
{
TrackBase::setLanguage(language);
if (m_sourceBuffer)
m_sourceBuffer->textTracks()->scheduleChangeEvent();
if (mediaElement())
mediaElement()->textTracks().scheduleChangeEvent();
}
#endif
}
#endif