#include "config.h"
#include "TextTrack.h"
#if ENABLE(VIDEO_TRACK)
#include "Document.h"
#include "Event.h"
#include "HTMLMediaElement.h"
#include "SourceBuffer.h"
#include "TextTrackCueList.h"
#include "TextTrackList.h"
#include "VTTRegion.h"
#include "VTTRegionList.h"
#include <wtf/NeverDestroyed.h>
namespace WebCore {
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(nullptr, nullptr, "off menu item", emptyAtom(), emptyAtom(), emptyAtom()).leakRef();
return &off;
}
TextTrack* TextTrack::captionMenuAutomaticItem()
{
static TextTrack& automatic = TextTrack::create(nullptr, nullptr, "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)
, ContextDestructionObserver(context)
, m_client(client)
, m_trackType(type)
{
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);
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 (keyword.isNull()) {
setKind(Kind::Subtitles);
return;
}
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);
else {
setKind(Kind::Metadata);
}
}
void TextTrack::setMode(Mode mode)
{
if (m_mode == mode)
return;
if (mode == Mode::Disabled && m_client && m_cues)
m_client->textTrackRemoveCues(*this, *m_cues);
if (mode != Mode::Showing && m_cues) {
for (size_t i = 0; i < m_cues->length(); ++i) {
RefPtr<TextTrackCue> cue = m_cues->item(i);
if (cue->isRenderable())
toVTTCue(cue.get())->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);
for (size_t i = 0; i < m_cues->length(); ++i)
m_cues->item(i)->setTrack(nullptr);
m_cues->clear();
}
TextTrackCueList* TextTrack::activeCues() const
{
if (!m_cues || m_mode == Mode::Disabled)
return nullptr;
return &m_cues->activeCues();
}
ExceptionOr<void> TextTrack::addCue(Ref<TextTrackCue>&& cue)
{
if (cue->cueType() == TextTrackCue::Data && m_kind != Kind::Metadata)
return Exception { InvalidNodeTypeError };
if (!cue->startMediaTime().isValid() || !cue->endMediaTime().isValid() || cue->startMediaTime() < MediaTime::zeroTime() || cue->endMediaTime() < MediaTime::zeroTime())
return { };
auto cueTrack = makeRefPtr(cue->track());
if (cueTrack == this)
return { };
if (cueTrack)
cueTrack->removeCue(cue.get());
cue->setTrack(this);
ensureTextTrackCueList().add(cue.copyRef());
if (m_client)
m_client->textTrackAddCue(*this, cue);
return { };
}
ExceptionOr<void> TextTrack::removeCue(TextTrackCue& cue)
{
if (cue.track() != this)
return Exception { NotFoundError };
if (!m_cues)
return Exception { InvalidStateError };
DEBUG_LOG(LOGIDENTIFIER, cue);
m_cues->remove(cue);
cue.setIsActive(false);
cue.setTrack(nullptr);
if (m_client)
m_client->textTrackRemoveCue(*this, cue);
return { };
}
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(RefPtr<VTTRegion>&& region)
{
if (!region)
return;
auto& regionList = ensureVTTRegionList();
auto regionTrack = makeRefPtr(region->track());
if (regionTrack && regionTrack != this)
regionTrack->removeRegion(region.get());
auto existingRegion = makeRefPtr(regionList.getRegionById(region->id()));
if (existingRegion) {
existingRegion->updateParametersFromRegion(*region);
return;
}
region->setTrack(this);
regionList.add(region.releaseNonNull());
}
ExceptionOr<void> TextTrack::removeRegion(VTTRegion* region)
{
if (!region)
return { };
if (region->track() != this)
return Exception { NotFoundError };
ASSERT(m_regions);
m_regions->remove(*region);
region->setTrack(nullptr);
return { };
}
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)
m_trackIndex = m_mediaElement->textTracks().getTrackIndex(*this);
return m_trackIndex.value();
}
void TextTrack::invalidateTrackIndex()
{
m_trackIndex = std::nullopt;
m_renderedTrackIndex = std::nullopt;
}
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)
m_renderedTrackIndex = m_mediaElement->textTracks().getTrackIndexRelativeToRenderedTracks(*this);
return m_renderedTrackIndex.value();
}
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());
RefPtr<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