#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()
{
DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, subtitles, ("subtitles", AtomicString::ConstructFromLiteral));
return subtitles;
}
const AtomicString& TextTrack::captionsKeyword()
{
DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, captions, ("captions", AtomicString::ConstructFromLiteral));
return captions;
}
const AtomicString& TextTrack::descriptionsKeyword()
{
DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, descriptions, ("descriptions", AtomicString::ConstructFromLiteral));
return descriptions;
}
const AtomicString& TextTrack::chaptersKeyword()
{
DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, chapters, ("chapters", AtomicString::ConstructFromLiteral));
return chapters;
}
const AtomicString& TextTrack::metadataKeyword()
{
DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, metadata, ("metadata", AtomicString::ConstructFromLiteral));
return metadata;
}
const AtomicString& TextTrack::forcedKeyword()
{
DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, forced, ("forced", AtomicString::ConstructFromLiteral));
return forced;
}
const AtomicString& TextTrack::disabledKeyword()
{
DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, open, ("disabled", AtomicString::ConstructFromLiteral));
return open;
}
const AtomicString& TextTrack::hiddenKeyword()
{
DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, closed, ("hidden", AtomicString::ConstructFromLiteral));
return closed;
}
const AtomicString& TextTrack::showingKeyword()
{
DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, ended, ("showing", AtomicString::ConstructFromLiteral));
return ended;
}
TextTrack* TextTrack::captionMenuOffItem()
{
static TextTrack* off = TextTrack::create(0, 0, "off menu item", "", "", "").leakRef();
return off;
}
TextTrack* TextTrack::captionMenuAutomaticItem()
{
static TextTrack* automatic = TextTrack::create(0, 0, "automatic menu item", "", "", "").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_cues(0)
#if ENABLE(WEBVTT_REGIONS)
, m_regions(0)
#endif
, m_scriptExecutionContext(context)
, m_mode(disabledKeyword().string())
, m_client(client)
, m_trackType(type)
, m_readinessState(NotLoaded)
, m_trackIndex(invalidTrackIndex)
, m_renderedTrackIndex(invalidTrackIndex)
, m_hasBeenConfigured(false)
{
setKindInternal(kind);
}
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(0);
#if ENABLE(WEBVTT_REGIONS)
if (m_regions) {
for (size_t i = 0; i < m_regions->length(); ++i)
m_regions->item(i)->setTrack(0);
}
#endif
}
clearClient();
}
bool TextTrack::isValidKind(const AtomicString& value) const
{
return TextTrack::isValidKindKeyword(value);
}
bool TextTrack::enabled() const
{
return m_mode != disabledKeyword();
}
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;
}
void TextTrack::setKind(const AtomicString& newKind)
{
String oldKind = kind();
#if ENABLE(MEDIA_SOURCE)
if (!isValidKindKeyword(newKind))
return;
setKindInternal(newKind);
if (m_sourceBuffer)
m_sourceBuffer->textTracks()->scheduleChangeEvent();
if (mediaElement())
mediaElement()->textTracks()->scheduleChangeEvent();
#else
TrackBase::setKind(newKind);
#endif
if (m_client && oldKind != kind())
m_client->textTrackKindChanged(this);
}
void TextTrack::setMode(const AtomicString& mode)
{
ASSERT(mode == disabledKeyword() || mode == hiddenKeyword() || mode == showingKeyword());
if (m_mode == mode)
return;
if (mode == disabledKeyword() && m_client && m_cues)
m_client->textTrackRemoveCues(this, m_cues.get());
if (mode != showingKeyword() && 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 != disabledKeyword())
return ensureTextTrackCueList();
return 0;
}
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(0);
m_cues = 0;
}
TextTrackCueList* TextTrack::activeCues() const
{
if (m_cues && m_mode != disabledKeyword())
return m_cues->activeCues();
return 0;
}
void TextTrack::addCue(PassRefPtr<TextTrackCue> prpCue, ExceptionCode& ec)
{
if (!prpCue)
return;
RefPtr<TextTrackCue> cue = prpCue;
if (cue->cueType() == TextTrackCue::Data && kind() != metadataKeyword()) {
ec = INVALID_NODE_TYPE_ERR;
return;
}
if (std::isnan(cue->startTime()) || std::isnan(cue->endTime()) || cue->startTime() < 0 || cue->endTime() < 0)
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);
}
#if ENABLE(VIDEO_TRACK) && ENABLE(WEBVTT_REGIONS)
VTTRegionList* TextTrack::ensureVTTRegionList()
{
if (!m_regions)
m_regions = VTTRegionList::create();
return m_regions.get();
}
VTTRegionList* TextTrack::regions()
{
if (m_mode != disabledKeyword())
return ensureVTTRegionList();
return 0;
}
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);
}
#endif
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()
{
if (kind() != captionsKeyword() && kind() != subtitlesKeyword() && kind() != forcedKeyword())
return false;
if (m_mode != showingKeyword())
return false;
return true;
}
TextTrackCueList* TextTrack::ensureTextTrackCueList()
{
if (!m_cues)
m_cues = TextTrackCueList::create();
return m_cues.get();
}
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->startTime() < 0 || cue->endTime() < 0)
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->startTime() > (existingCue->startTime() + startTimeVariance()))
return false;
if (existingCue->isEqual(*cue, match))
return true;
}
}
size_t index = (searchStart + searchEnd) / 2;
existingCue = m_cues->item(index);
if ((cue->startTime() + startTimeVariance()) < existingCue->startTime() || (match != TextTrackCue::IgnoreDuration && cue->hasEquivalentStartTime(*existingCue) && cue->endTime() > existingCue->endTime()))
searchEnd = index;
else
searchStart = index + 1;
}
ASSERT_NOT_REACHED();
return false;
}
#if USE(PLATFORM_TEXT_TRACK_MENU)
PassRefPtr<PlatformTextTrack> TextTrack::platformTextTrack()
{
if (m_platformTextTrack)
return m_platformTextTrack;
PlatformTextTrack::TrackKind platformKind = PlatformTextTrack::Caption;
if (kind() == subtitlesKeyword())
platformKind = PlatformTextTrack::Subtitle;
else if (kind() == captionsKeyword())
platformKind = PlatformTextTrack::Caption;
else if (kind() == descriptionsKeyword())
platformKind = PlatformTextTrack::Description;
else if (kind() == chaptersKeyword())
platformKind = PlatformTextTrack::Chapter;
else if (kind() == metadataKeyword())
platformKind = PlatformTextTrack::MetaData;
else if (kind() == forcedKeyword())
platformKind = PlatformTextTrack::Forced;
PlatformTextTrack::TrackType type = PlatformTextTrack::OutOfBand;
if (m_trackType == TrackElement)
type = PlatformTextTrack::OutOfBand;
else if (m_trackType == AddTrack)
type = PlatformTextTrack::Script;
else if (m_trackType == InBand)
type = PlatformTextTrack::InBand;
PlatformTextTrack::TrackMode platformMode = PlatformTextTrack::Disabled;
if (TextTrack::hiddenKeyword() == mode())
platformMode = PlatformTextTrack::Hidden;
else if (TextTrack::disabledKeyword() == mode())
platformMode = PlatformTextTrack::Disabled;
else if (TextTrack::showingKeyword() == mode())
platformMode = PlatformTextTrack::Showing;
m_platformTextTrack = PlatformTextTrack::create(this, label(), language(), platformMode, platformKind, type, uniqueId());
return m_platformTextTrack;
}
#endif
bool TextTrack::isMainProgramContent() const
{
return kind() == captionsKeyword();
}
#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