/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package androidx.media3.extractor.text.ttml;
import static androidx.media3.common.util.Assertions.checkNotNull;
import android.text.Spannable;
import android.text.SpannableStringBuilder;
import android.text.Spanned;
import android.text.style.AbsoluteSizeSpan;
import android.text.style.BackgroundColorSpan;
import android.text.style.ForegroundColorSpan;
import android.text.style.RelativeSizeSpan;
import android.text.style.StrikethroughSpan;
import android.text.style.StyleSpan;
import android.text.style.TypefaceSpan;
import android.text.style.UnderlineSpan;
import androidx.annotation.Nullable;
import androidx.media3.common.text.Cue;
import androidx.media3.common.text.HorizontalTextInVerticalContextSpan;
import androidx.media3.common.text.RubySpan;
import androidx.media3.common.text.SpanUtil;
import androidx.media3.common.text.TextAnnotation;
import androidx.media3.common.text.TextEmphasisSpan;
import androidx.media3.common.util.Log;
import androidx.media3.common.util.Util;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Map;
/** Package internal utility class to render styled <code>TtmlNode</code>s. */
/* package */ final class TtmlRenderUtil {
private static final String TAG = "TtmlRenderUtil";
@Nullable
public static TtmlStyle resolveStyle(
@Nullable TtmlStyle style, @Nullable String[] styleIds, Map<String, TtmlStyle> globalStyles) {
if (style == null) {
if (styleIds == null) {
// No styles at all.
return null;
} else if (styleIds.length == 1) {
// Only one single referential style present.
return globalStyles.get(styleIds[0]);
} else if (styleIds.length > 1) {
// Only multiple referential styles present.
TtmlStyle chainedStyle = new TtmlStyle();
for (String id : styleIds) {
chainedStyle.chain(globalStyles.get(id));
}
return chainedStyle;
}
} else /* style != null */ {
if (styleIds != null && styleIds.length == 1) {
// Merge a single referential style into inline style.
return style.chain(globalStyles.get(styleIds[0]));
} else if (styleIds != null && styleIds.length > 1) {
// Merge multiple referential styles into inline style.
for (String id : styleIds) {
style.chain(globalStyles.get(id));
}
return style;
}
}
// Only inline styles available.
return style;
}
public static void applyStylesToSpan(
Spannable builder,
int start,
int end,
TtmlStyle style,
@Nullable TtmlNode parent,
Map<String, TtmlStyle> globalStyles,
@Cue.VerticalType int verticalType) {
if (style.getStyle() != TtmlStyle.UNSPECIFIED) {
builder.setSpan(
new StyleSpan(style.getStyle()), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
}
if (style.isLinethrough()) {
builder.setSpan(new StrikethroughSpan(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
}
if (style.isUnderline()) {
builder.setSpan(new UnderlineSpan(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
}
if (style.hasFontColor()) {
SpanUtil.addOrReplaceSpan(
builder,
new ForegroundColorSpan(style.getFontColor()),
start,
end,
Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
}
if (style.hasBackgroundColor()) {
SpanUtil.addOrReplaceSpan(
builder,
new BackgroundColorSpan(style.getBackgroundColor()),
start,
end,
Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
}
if (style.getFontFamily() != null) {
SpanUtil.addOrReplaceSpan(
builder,
new TypefaceSpan(style.getFontFamily()),
start,
end,
Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
}
if (style.getTextEmphasis() != null) {
TextEmphasis textEmphasis = checkNotNull(style.getTextEmphasis());
@TextEmphasisSpan.MarkShape int markShape;
@TextEmphasisSpan.MarkFill int markFill;
if (textEmphasis.markShape == TextEmphasis.MARK_SHAPE_AUTO) {
// If a vertical writing mode applies, then 'auto' is equivalent to 'filled sesame';
// otherwise, it's equivalent to 'filled circle':
// https://www.w3.org/TR/ttml2/#style-value-emphasis-style
markShape =
(verticalType == Cue.VERTICAL_TYPE_LR || verticalType == Cue.VERTICAL_TYPE_RL)
? TextEmphasisSpan.MARK_SHAPE_SESAME
: TextEmphasisSpan.MARK_SHAPE_CIRCLE;
markFill = TextEmphasisSpan.MARK_FILL_FILLED;
} else {
markShape = textEmphasis.markShape;
markFill = textEmphasis.markFill;
}
@TextEmphasis.Position int position;
if (textEmphasis.position == TextEmphasis.POSITION_OUTSIDE) {
// 'outside' is not supported by TextEmphasisSpan, so treat it as 'before':
// https://www.w3.org/TR/ttml2/#style-value-annotation-position
position = TextAnnotation.POSITION_BEFORE;
} else {
position = textEmphasis.position;
}
SpanUtil.addOrReplaceSpan(
builder,
new TextEmphasisSpan(markShape, markFill, position),
start,
end,
Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
}
switch (style.getRubyType()) {
case TtmlStyle.RUBY_TYPE_BASE:
// look for the sibling RUBY_TEXT and add it as span between start & end.
@Nullable TtmlNode containerNode = findRubyContainerNode(parent, globalStyles);
if (containerNode == null) {
// No matching container node
break;
}
@Nullable TtmlNode textNode = findRubyTextNode(containerNode, globalStyles);
if (textNode == null) {
// no matching text node
break;
}
String rubyText;
if (textNode.getChildCount() == 1 && textNode.getChild(0).text != null) {
rubyText = Util.castNonNull(textNode.getChild(0).text);
} else {
Log.i(TAG, "Skipping rubyText node without exactly one text child.");
break;
}
@Nullable
TtmlStyle textStyle = resolveStyle(textNode.style, textNode.getStyleIds(), globalStyles);
// Use position from ruby text node if defined.
@TextAnnotation.Position
int rubyPosition =
textStyle != null ? textStyle.getRubyPosition() : TextAnnotation.POSITION_UNKNOWN;
if (rubyPosition == TextAnnotation.POSITION_UNKNOWN) {
// If ruby position is not defined, use position info from container node.
@Nullable
TtmlStyle containerStyle =
resolveStyle(containerNode.style, containerNode.getStyleIds(), globalStyles);
rubyPosition = containerStyle != null ? containerStyle.getRubyPosition() : rubyPosition;
}
builder.setSpan(
new RubySpan(rubyText, rubyPosition), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
break;
case TtmlStyle.RUBY_TYPE_DELIMITER:
// TODO: Add support for this when RubySpan supports parenthetical text. For now, just
// fall through and delete the text.
case TtmlStyle.RUBY_TYPE_TEXT:
// We can't just remove the text directly from `builder` here because TtmlNode has fixed
// ideas of where every node starts and ends (nodeStartsByRegion and nodeEndsByRegion) so
// all these indices become invalid if we mutate the underlying string at this point.
// Instead we add a special span that's then handled in TtmlNode#cleanUpText.
builder.setSpan(new DeleteTextSpan(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
break;
case TtmlStyle.RUBY_TYPE_CONTAINER:
case TtmlStyle.UNSPECIFIED:
default:
// Do nothing
break;
}
if (style.getTextCombine()) {
SpanUtil.addOrReplaceSpan(
builder,
new HorizontalTextInVerticalContextSpan(),
start,
end,
Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
}
switch (style.getFontSizeUnit()) {
case TtmlStyle.FONT_SIZE_UNIT_PIXEL:
SpanUtil.addOrReplaceSpan(
builder,
new AbsoluteSizeSpan((int) style.getFontSize(), true),
start,
end,
Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
break;
case TtmlStyle.FONT_SIZE_UNIT_EM:
SpanUtil.addOrReplaceSpan(
builder,
new RelativeSizeSpan(style.getFontSize()),
start,
end,
Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
break;
case TtmlStyle.FONT_SIZE_UNIT_PERCENT:
SpanUtil.addOrReplaceSpan(
builder,
new RelativeSizeSpan(style.getFontSize() / 100),
start,
end,
Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
break;
case TtmlStyle.UNSPECIFIED:
// Do nothing.
break;
}
}
@Nullable
private static TtmlNode findRubyTextNode(
TtmlNode rubyContainerNode, Map<String, TtmlStyle> globalStyles) {
Deque<TtmlNode> childNodesStack = new ArrayDeque<>();
childNodesStack.push(rubyContainerNode);
while (!childNodesStack.isEmpty()) {
TtmlNode childNode = childNodesStack.pop();
@Nullable
TtmlStyle style = resolveStyle(childNode.style, childNode.getStyleIds(), globalStyles);
if (style != null && style.getRubyType() == TtmlStyle.RUBY_TYPE_TEXT) {
return childNode;
}
for (int i = childNode.getChildCount() - 1; i >= 0; i--) {
childNodesStack.push(childNode.getChild(i));
}
}
return null;
}
@Nullable
private static TtmlNode findRubyContainerNode(
@Nullable TtmlNode node, Map<String, TtmlStyle> globalStyles) {
while (node != null) {
@Nullable TtmlStyle style = resolveStyle(node.style, node.getStyleIds(), globalStyles);
if (style != null && style.getRubyType() == TtmlStyle.RUBY_TYPE_CONTAINER) {
return node;
}
node = node.parent;
}
return null;
}
/**
* Called when the end of a paragraph is encountered. Adds a newline if there are one or more
* non-space characters since the previous newline.
*
* @param builder The builder.
*/
/* package */ static void endParagraph(SpannableStringBuilder builder) {
int position = builder.length() - 1;
while (position >= 0 && builder.charAt(position) == ' ') {
position--;
}
if (position >= 0 && builder.charAt(position) != '\n') {
builder.append('\n');
}
}
/**
* Applies the appropriate space policy to the given text element.
*
* @param in The text element to which the policy should be applied.
* @return The result of applying the policy to the text element.
*/
/* package */ static String applyTextElementSpacePolicy(String in) {
// Removes carriage return followed by line feed. See: http://www.w3.org/TR/xml/#sec-line-ends
String out = in.replaceAll("\r\n", "\n");
// Apply suppress-at-line-break="auto" and
// white-space-treatment="ignore-if-surrounding-linefeed"
out = out.replaceAll(" *\n *", "\n");
// Apply linefeed-treatment="treat-as-space"
out = out.replaceAll("\n", " ");
// Apply white-space-collapse="true"
out = out.replaceAll("[ \t\x0B\f\r]+", " ");
return out;
}
private TtmlRenderUtil() {}
}