Google Git Google Git
Sign in
android/platform/prebuilts/fullsdk/sources/refs/heads/androidx-annotation-annotation-experimental-release/./android-34/android/media/Cea708CaptionRenderer.java
blob: 88912fef45010bd1bdbc7ef1a4f86be66ed94cb4 [file] [edit]
/*
* Copyright (C) 2015 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 android.media;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.Typeface;
import android.os.Handler;
import android.os.Message;
import android.text.SpannableStringBuilder;
import android.text.Spanned;
import android.text.style.CharacterStyle;
import android.text.style.RelativeSizeSpan;
import android.text.style.StyleSpan;
import android.text.style.SubscriptSpan;
import android.text.style.SuperscriptSpan;
import android.text.style.UnderlineSpan;
import android.util.AttributeSet;
import android.text.Layout.Alignment;
import android.util.Log;
import android.text.TextUtils;
import android.view.Gravity;
import android.view.View;
import android.view.ViewGroup;
import android.view.accessibility.CaptioningManager;
import android.view.accessibility.CaptioningManager.CaptionStyle;
import android.widget.RelativeLayout;
import android.widget.TextView;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Vector;
import com.android.internal.widget.SubtitleView;
/** @hide */
public class Cea708CaptionRenderer extends SubtitleController.Renderer {
private final Context mContext;
private Cea708CCWidget mCCWidget;
public Cea708CaptionRenderer(Context context) {
mContext = context;
}
@Override
public boolean supports(MediaFormat format) {
if (format.containsKey(MediaFormat.KEY_MIME)) {
String mimeType = format.getString(MediaFormat.KEY_MIME);
return MediaPlayer.MEDIA_MIMETYPE_TEXT_CEA_708.equals(mimeType);
}
return false;
}
@Override
public SubtitleTrack createTrack(MediaFormat format) {
String mimeType = format.getString(MediaFormat.KEY_MIME);
if (MediaPlayer.MEDIA_MIMETYPE_TEXT_CEA_708.equals(mimeType)) {
if (mCCWidget == null) {
mCCWidget = new Cea708CCWidget(mContext);
}
return new Cea708CaptionTrack(mCCWidget, format);
}
throw new RuntimeException("No matching format: " + format.toString());
}
}
/** @hide */
class Cea708CaptionTrack extends SubtitleTrack {
private final Cea708CCParser mCCParser;
private final Cea708CCWidget mRenderingWidget;
Cea708CaptionTrack(Cea708CCWidget renderingWidget, MediaFormat format) {
super(format);
mRenderingWidget = renderingWidget;
mCCParser = new Cea708CCParser(mRenderingWidget);
}
@Override
public void onData(byte[] data, boolean eos, long runID) {
mCCParser.parse(data);
}
@Override
public RenderingWidget getRenderingWidget() {
return mRenderingWidget;
}
@Override
public void updateView(Vector<Cue> activeCues) {
// Overriding with NO-OP, CC rendering by-passes this
}
}
/**
* @hide
*
* A class for parsing CEA-708, which is the standard for closed captioning for ATSC DTV.
*
* <p>ATSC DTV closed caption data are carried on picture user data of video streams.
* This class starts to parse from picture user data payload, so extraction process of user_data
* from video streams is up to outside of this code.
*
* <p>There are 4 steps to decode user_data to provide closed caption services. Step 1 and 2 are
* done in NuPlayer and libstagefright.
*
* <h3>Step 1. user_data -&gt; CcPacket</h3>
*
* <p>First, user_data consists of cc_data packets, which are 3-byte segments. Here, CcPacket is a
* collection of cc_data packets in a frame along with same presentation timestamp. Because cc_data
* packets must be reassembled in the frame display order, CcPackets are reordered.
*
* <h3>Step 2. CcPacket -&gt; DTVCC packet</h3>
*
* <p>Each cc_data packet has a one byte for declaring a type of itself and data validity, and the
* subsequent two bytes for input data of a DTVCC packet. There are 4 types for cc_data packet.
* We're interested in DTVCC_PACKET_START(type 3) and DTVCC_PACKET_DATA(type 2). Each DTVCC packet
* begins with DTVCC_PACKET_START(type 3) and the following cc_data packets which has
* DTVCC_PACKET_DATA(type 2) are appended into the DTVCC packet being assembled.
*
* <h3>Step 3. DTVCC packet -&gt; Service Blocks</h3>
*
* <p>A DTVCC packet consists of multiple service blocks. Each service block represents a caption
* track and has a service number, which ranges from 1 to 63, that denotes caption track identity.
* In here, we listen at most one chosen caption track by service number. Otherwise, just skip the
* other service blocks.
*
* <h3>Step 4. Interpreting Service Block Data ({@link #parseServiceBlockData}, {@code parseXX},
* and {@link #parseExt1} methods)</h3>
*
* <p>Service block data is actual caption stream. it looks similar to telnet. It uses most parts of
* ASCII table and consists of specially defined commands and some ASCII control codes which work
* in a behavior slightly different from their original purpose. ASCII control codes and caption
* commands are explicit instructions that control the state of a closed caption service and the
* other ASCII and text codes are implicit instructions that send their characters to buffer.
*
* <p>There are 4 main code groups and 4 extended code groups. Both the range of code groups are the
* same as the range of a byte.
*
* <p>4 main code groups: C0, C1, G0, G1
* <br>4 extended code groups: C2, C3, G2, G3
*
* <p>Each code group has its own handle method. For example, {@link #parseC0} handles C0 code group
* and so on. And {@link #parseServiceBlockData} method maps a stream on the main code groups while
* {@link #parseExt1} method maps on the extended code groups.
*
* <p>The main code groups:
* <ul>
* <li>C0 - contains modified ASCII control codes. It is not intended by CEA-708 but Korea TTA
* standard for ATSC CC uses P16 character heavily, which is unclear entity in CEA-708 doc,
* even for the alphanumeric characters instead of ASCII characters.</li>
* <li>C1 - contains the caption commands. There are 3 categories of a caption command.</li>
* <ul>
* <li>Window commands: The window commands control a caption window which is addressable area being
* with in the Safe title area. (CWX, CLW, DSW, HDW, TGW, DLW, SWA, DFX)</li>
* <li>Pen commands: Th pen commands control text style and location. (SPA, SPC, SPL)</li>
* <li>Job commands: The job commands make a delay and recover from the delay. (DLY, DLC, RST)</li>
* </ul>
* <li>G0 - same as printable ASCII character set except music note character.</li>
* <li>G1 - same as ISO 8859-1 Latin 1 character set.</li>
* </ul>
* <p>Most of the extended code groups are being skipped.
*
*/
class Cea708CCParser {
private static final String TAG = "Cea708CCParser";
private static final boolean DEBUG = false;
private static final String MUSIC_NOTE_CHAR = new String(
"\u266B".getBytes(StandardCharsets.UTF_8), StandardCharsets.UTF_8);
private final StringBuffer mBuffer = new StringBuffer();
private int mCommand = 0;
// Assign a dummy listener in order to avoid null checks.
private DisplayListener mListener = new DisplayListener() {
@Override
public void emitEvent(CaptionEvent event) {
// do nothing
}
};
/**
* {@link Cea708Parser} emits caption event of three different types.
* {@link DisplayListener#emitEvent} is invoked with the parameter
* {@link CaptionEvent} to pass all the results to an observer of the decoding process .
*
* <p>{@link CaptionEvent#type} determines the type of the result and
* {@link CaptionEvent#obj} contains the output value of a caption event.
* The observer must do the casting to the corresponding type.
*
* <ul><li>{@code CAPTION_EMIT_TYPE_BUFFER}: Passes a caption text buffer to a observer.
* {@code obj} must be of {@link String}.</li>
*
* <li>{@code CAPTION_EMIT_TYPE_CONTROL}: Passes a caption character control code to a observer.
* {@code obj} must be of {@link Character}.</li>
*
* <li>{@code CAPTION_EMIT_TYPE_CLEAR_COMMAND}: Passes a clear command to a observer.
* {@code obj} must be {@code NULL}.</li></ul>
*/
public static final int CAPTION_EMIT_TYPE_BUFFER = 1;
public static final int CAPTION_EMIT_TYPE_CONTROL = 2;
public static final int CAPTION_EMIT_TYPE_COMMAND_CWX = 3;
public static final int CAPTION_EMIT_TYPE_COMMAND_CLW = 4;
public static final int CAPTION_EMIT_TYPE_COMMAND_DSW = 5;
public static final int CAPTION_EMIT_TYPE_COMMAND_HDW = 6;
public static final int CAPTION_EMIT_TYPE_COMMAND_TGW = 7;
public static final int CAPTION_EMIT_TYPE_COMMAND_DLW = 8;
public static final int CAPTION_EMIT_TYPE_COMMAND_DLY = 9;
public static final int CAPTION_EMIT_TYPE_COMMAND_DLC = 10;
public static final int CAPTION_EMIT_TYPE_COMMAND_RST = 11;
public static final int CAPTION_EMIT_TYPE_COMMAND_SPA = 12;
public static final int CAPTION_EMIT_TYPE_COMMAND_SPC = 13;
public static final int CAPTION_EMIT_TYPE_COMMAND_SPL = 14;
public static final int CAPTION_EMIT_TYPE_COMMAND_SWA = 15;
public static final int CAPTION_EMIT_TYPE_COMMAND_DFX = 16;
Cea708CCParser(DisplayListener listener) {
if (listener != null) {
mListener = listener;
}
}
interface DisplayListener {
void emitEvent(CaptionEvent event);
}
private void emitCaptionEvent(CaptionEvent captionEvent) {
// Emit the existing string buffer before a new event is arrived.
emitCaptionBuffer();
mListener.emitEvent(captionEvent);
}
private void emitCaptionBuffer() {
if (mBuffer.length() > 0) {
mListener.emitEvent(new CaptionEvent(CAPTION_EMIT_TYPE_BUFFER, mBuffer.toString()));
mBuffer.setLength(0);
}
}
// Step 3. DTVCC packet -> Service Blocks (parseDtvCcPacket method)
public void parse(byte[] data) {
// From this point, starts to read DTVCC coding layer.
// First, identify code groups, which is defined in CEA-708B Section 7.1.
int pos = 0;
while (pos < data.length) {
pos = parseServiceBlockData(data, pos);
}
// Emit the buffer after reading codes.
emitCaptionBuffer();
}
// Step 4. Main code groups
private int parseServiceBlockData(byte[] data, int pos) {
// For the details of the ranges of DTVCC code groups, see CEA-708B Table 6.
mCommand = data[pos] & 0xff;
++pos;
if (mCommand == Const.CODE_C0_EXT1) {
if (DEBUG) {
Log.d(TAG, String.format("parseServiceBlockData EXT1 %x", mCommand));
}
pos = parseExt1(data, pos);
} else if (mCommand >= Const.CODE_C0_RANGE_START
&& mCommand <= Const.CODE_C0_RANGE_END) {
if (DEBUG) {
Log.d(TAG, String.format("parseServiceBlockData C0 %x", mCommand));
}
pos = parseC0(data, pos);
} else if (mCommand >= Const.CODE_C1_RANGE_START
&& mCommand <= Const.CODE_C1_RANGE_END) {
if (DEBUG) {
Log.d(TAG, String.format("parseServiceBlockData C1 %x", mCommand));
}
pos = parseC1(data, pos);
} else if (mCommand >= Const.CODE_G0_RANGE_START
&& mCommand <= Const.CODE_G0_RANGE_END) {
if (DEBUG) {
Log.d(TAG, String.format("parseServiceBlockData G0 %x", mCommand));
}
pos = parseG0(data, pos);
} else if (mCommand >= Const.CODE_G1_RANGE_START
&& mCommand <= Const.CODE_G1_RANGE_END) {
if (DEBUG) {
Log.d(TAG, String.format("parseServiceBlockData G1 %x", mCommand));
}
pos = parseG1(data, pos);
}
return pos;
}
private int parseC0(byte[] data, int pos) {
// For the details of C0 code group, see CEA-708B Section 7.4.1.
// CL Group: C0 Subset of ASCII Control codes
if (mCommand >= Const.CODE_C0_SKIP2_RANGE_START
&& mCommand <= Const.CODE_C0_SKIP2_RANGE_END) {
if (mCommand == Const.CODE_C0_P16) {
// P16 escapes next two bytes for the large character maps.(no standard rule)
// For Korea broadcasting, express whole letters by using this.
try {
if (data[pos] == 0) {
mBuffer.append((char) data[pos + 1]);
} else {
String value = new String(Arrays.copyOfRange(data, pos, pos + 2), "EUC-KR");
mBuffer.append(value);
}
} catch (UnsupportedEncodingException e) {
Log.e(TAG, "P16 Code - Could not find supported encoding", e);
}
}
pos += 2;
} else if (mCommand >= Const.CODE_C0_SKIP1_RANGE_START
&& mCommand <= Const.CODE_C0_SKIP1_RANGE_END) {
++pos;
} else {
// NUL, BS, FF, CR interpreted as they are in ASCII control codes.
// HCR moves the pen location to th beginning of the current line and deletes contents.
// FF clears the screen and moves the pen location to (0,0).
// ETX is the NULL command which is used to flush text to the current window when no
// other command is pending.
switch (mCommand) {
case Const.CODE_C0_NUL:
break;
case Const.CODE_C0_ETX:
emitCaptionEvent(new CaptionEvent(CAPTION_EMIT_TYPE_CONTROL, (char) mCommand));
break;
case Const.CODE_C0_BS:
emitCaptionEvent(new CaptionEvent(CAPTION_EMIT_TYPE_CONTROL, (char) mCommand));
break;
case Const.CODE_C0_FF:
emitCaptionEvent(new CaptionEvent(CAPTION_EMIT_TYPE_CONTROL, (char) mCommand));
break;
case Const.CODE_C0_CR:
mBuffer.append('\n');
break;
case Const.CODE_C0_HCR:
emitCaptionEvent(new CaptionEvent(CAPTION_EMIT_TYPE_CONTROL, (char) mCommand));
break;
default:
break;
}
}
return pos;
}
private int parseC1(byte[] data, int pos) {
// For the details of C1 code group, see CEA-708B Section 8.10.
// CR Group: C1 Caption Control Codes
switch (mCommand) {
case Const.CODE_C1_CW0:
case Const.CODE_C1_CW1:
case Const.CODE_C1_CW2:
case Const.CODE_C1_CW3:
case Const.CODE_C1_CW4:
case Const.CODE_C1_CW5:
case Const.CODE_C1_CW6:
case Const.CODE_C1_CW7: {
// SetCurrentWindow0-7
int windowId = mCommand - Const.CODE_C1_CW0;
emitCaptionEvent(new CaptionEvent(CAPTION_EMIT_TYPE_COMMAND_CWX, windowId));
if (DEBUG) {
Log.d(TAG, String.format("CaptionCommand CWX windowId: %d", windowId));
}
break;
}
case Const.CODE_C1_CLW: {
// ClearWindows
int windowBitmap = data[pos] & 0xff;
++pos;
emitCaptionEvent(new CaptionEvent(CAPTION_EMIT_TYPE_COMMAND_CLW, windowBitmap));
if (DEBUG) {
Log.d(TAG, String.format("CaptionCommand CLW windowBitmap: %d", windowBitmap));
}
break;
}
case Const.CODE_C1_DSW: {
// DisplayWindows
int windowBitmap = data[pos] & 0xff;
++pos;
emitCaptionEvent(new CaptionEvent(CAPTION_EMIT_TYPE_COMMAND_DSW, windowBitmap));
if (DEBUG) {
Log.d(TAG, String.format("CaptionCommand DSW windowBitmap: %d", windowBitmap));
}
break;
}
case Const.CODE_C1_HDW: {
// HideWindows
int windowBitmap = data[pos] & 0xff;
++pos;
emitCaptionEvent(new CaptionEvent(CAPTION_EMIT_TYPE_COMMAND_HDW, windowBitmap));
if (DEBUG) {
Log.d(TAG, String.format("CaptionCommand HDW windowBitmap: %d", windowBitmap));
}
break;
}
case Const.CODE_C1_TGW: {
// ToggleWindows
int windowBitmap = data[pos] & 0xff;
++pos;
emitCaptionEvent(new CaptionEvent(CAPTION_EMIT_TYPE_COMMAND_TGW, windowBitmap));
if (DEBUG) {
Log.d(TAG, String.format("CaptionCommand TGW windowBitmap: %d", windowBitmap));
}
break;
}
case Const.CODE_C1_DLW: {
// DeleteWindows
int windowBitmap = data[pos] & 0xff;
++pos;
emitCaptionEvent(new CaptionEvent(CAPTION_EMIT_TYPE_COMMAND_DLW, windowBitmap));
if (DEBUG) {
Log.d(TAG, String.format("CaptionCommand DLW windowBitmap: %d", windowBitmap));
}
break;
}
case Const.CODE_C1_DLY: {
// Delay
int tenthsOfSeconds = data[pos] & 0xff;
++pos;
emitCaptionEvent(new CaptionEvent(CAPTION_EMIT_TYPE_COMMAND_DLY, tenthsOfSeconds));
if (DEBUG) {
Log.d(TAG, String.format("CaptionCommand DLY %d tenths of seconds",
tenthsOfSeconds));
}
break;
}
case Const.CODE_C1_DLC: {
// DelayCancel
emitCaptionEvent(new CaptionEvent(CAPTION_EMIT_TYPE_COMMAND_DLC, null));
if (DEBUG) {
Log.d(TAG, "CaptionCommand DLC");
}
break;
}
case Const.CODE_C1_RST: {
// Reset
emitCaptionEvent(new CaptionEvent(CAPTION_EMIT_TYPE_COMMAND_RST, null));
if (DEBUG) {
Log.d(TAG, "CaptionCommand RST");
}
break;
}
case Const.CODE_C1_SPA: {
// SetPenAttributes
int textTag = (data[pos] & 0xf0) >> 4;
int penSize = data[pos] & 0x03;
int penOffset = (data[pos] & 0x0c) >> 2;
boolean italic = (data[pos + 1] & 0x80) != 0;
boolean underline = (data[pos + 1] & 0x40) != 0;
int edgeType = (data[pos + 1] & 0x38) >> 3;
int fontTag = data[pos + 1] & 0x7;
pos += 2;
emitCaptionEvent(new CaptionEvent(CAPTION_EMIT_TYPE_COMMAND_SPA,
new CaptionPenAttr(penSize, penOffset, textTag, fontTag, edgeType,
underline, italic)));
if (DEBUG) {
Log.d(TAG, String.format(
"CaptionCommand SPA penSize: %d, penOffset: %d, textTag: %d, "
+ "fontTag: %d, edgeType: %d, underline: %s, italic: %s",
penSize, penOffset, textTag, fontTag, edgeType, underline, italic));
}
break;
}
case Const.CODE_C1_SPC: {
// SetPenColor
int opacity = (data[pos] & 0xc0) >> 6;
int red = (data[pos] & 0x30) >> 4;
int green = (data[pos] & 0x0c) >> 2;
int blue = data[pos] & 0x03;
CaptionColor foregroundColor = new CaptionColor(opacity, red, green, blue);
++pos;
opacity = (data[pos] & 0xc0) >> 6;
red = (data[pos] & 0x30) >> 4;
green = (data[pos] & 0x0c) >> 2;
blue = data[pos] & 0x03;
CaptionColor backgroundColor = new CaptionColor(opacity, red, green, blue);
++pos;
red = (data[pos] & 0x30) >> 4;
green = (data[pos] & 0x0c) >> 2;
blue = data[pos] & 0x03;
CaptionColor edgeColor = new CaptionColor(
CaptionColor.OPACITY_SOLID, red, green, blue);
++pos;
emitCaptionEvent(new CaptionEvent(CAPTION_EMIT_TYPE_COMMAND_SPC,
new CaptionPenColor(foregroundColor, backgroundColor, edgeColor)));
if (DEBUG) {
Log.d(TAG, String.format(
"CaptionCommand SPC foregroundColor %s backgroundColor %s edgeColor %s",
foregroundColor, backgroundColor, edgeColor));
}
break;
}
case Const.CODE_C1_SPL: {
// SetPenLocation
// column is normally 0-31 for 4:3 formats, and 0-41 for 16:9 formats
int row = data[pos] & 0x0f;
int column = data[pos + 1] & 0x3f;
pos += 2;
emitCaptionEvent(new CaptionEvent(CAPTION_EMIT_TYPE_COMMAND_SPL,
new CaptionPenLocation(row, column)));
if (DEBUG) {
Log.d(TAG, String.format("CaptionCommand SPL row: %d, column: %d",
row, column));
}
break;
}
case Const.CODE_C1_SWA: {
// SetWindowAttributes
int opacity = (data[pos] & 0xc0) >> 6;
int red = (data[pos] & 0x30) >> 4;
int green = (data[pos] & 0x0c) >> 2;
int blue = data[pos] & 0x03;
CaptionColor fillColor = new CaptionColor(opacity, red, green, blue);
int borderType = (data[pos + 1] & 0xc0) >> 6 | (data[pos + 2] & 0x80) >> 5;
red = (data[pos + 1] & 0x30) >> 4;
green = (data[pos + 1] & 0x0c) >> 2;
blue = data[pos + 1] & 0x03;
CaptionColor borderColor = new CaptionColor(
CaptionColor.OPACITY_SOLID, red, green, blue);
boolean wordWrap = (data[pos + 2] & 0x40) != 0;
int printDirection = (data[pos + 2] & 0x30) >> 4;
int scrollDirection = (data[pos + 2] & 0x0c) >> 2;
int justify = (data[pos + 2] & 0x03);
int effectSpeed = (data[pos + 3] & 0xf0) >> 4;
int effectDirection = (data[pos + 3] & 0x0c) >> 2;
int displayEffect = data[pos + 3] & 0x3;
pos += 4;
emitCaptionEvent(new CaptionEvent(CAPTION_EMIT_TYPE_COMMAND_SWA,
new CaptionWindowAttr(fillColor, borderColor, borderType, wordWrap,
printDirection, scrollDirection, justify,
effectDirection, effectSpeed, displayEffect)));
if (DEBUG) {
Log.d(TAG, String.format(
"CaptionCommand SWA fillColor: %s, borderColor: %s, borderType: %d"
+ "wordWrap: %s, printDirection: %d, scrollDirection: %d, "
+ "justify: %s, effectDirection: %d, effectSpeed: %d, "
+ "displayEffect: %d",
fillColor, borderColor, borderType, wordWrap, printDirection,
scrollDirection, justify, effectDirection, effectSpeed, displayEffect));
}
break;
}
case Const.CODE_C1_DF0:
case Const.CODE_C1_DF1:
case Const.CODE_C1_DF2:
case Const.CODE_C1_DF3:
case Const.CODE_C1_DF4:
case Const.CODE_C1_DF5:
case Const.CODE_C1_DF6:
case Const.CODE_C1_DF7: {
// DefineWindow0-7
int windowId = mCommand - Const.CODE_C1_DF0;
boolean visible = (data[pos] & 0x20) != 0;
boolean rowLock = (data[pos] & 0x10) != 0;
boolean columnLock = (data[pos] & 0x08) != 0;
int priority = data[pos] & 0x07;
boolean relativePositioning = (data[pos + 1] & 0x80) != 0;
int anchorVertical = data[pos + 1] & 0x7f;
int anchorHorizontal = data[pos + 2] & 0xff;
int anchorId = (data[pos + 3] & 0xf0) >> 4;
int rowCount = data[pos + 3] & 0x0f;
int columnCount = data[pos + 4] & 0x3f;
int windowStyle = (data[pos + 5] & 0x38) >> 3;
int penStyle = data[pos + 5] & 0x07;
pos += 6;
emitCaptionEvent(new CaptionEvent(CAPTION_EMIT_TYPE_COMMAND_DFX,
new CaptionWindow(windowId, visible, rowLock, columnLock, priority,
relativePositioning, anchorVertical, anchorHorizontal, anchorId,
rowCount, columnCount, penStyle, windowStyle)));
if (DEBUG) {
Log.d(TAG, String.format(
"CaptionCommand DFx windowId: %d, priority: %d, columnLock: %s, "
+ "rowLock: %s, visible: %s, anchorVertical: %d, "
+ "relativePositioning: %s, anchorHorizontal: %d, "
+ "rowCount: %d, anchorId: %d, columnCount: %d, penStyle: %d, "
+ "windowStyle: %d",
windowId, priority, columnLock, rowLock, visible, anchorVertical,
relativePositioning, anchorHorizontal, rowCount, anchorId, columnCount,
penStyle, windowStyle));
}
break;
}
default:
break;
}
return pos;
}
private int parseG0(byte[] data, int pos) {
// For the details of G0 code group, see CEA-708B Section 7.4.3.
// GL Group: G0 Modified version of ANSI X3.4 Printable Character Set (ASCII)
if (mCommand == Const.CODE_G0_MUSICNOTE) {
// Music note.
mBuffer.append(MUSIC_NOTE_CHAR);
} else {
// Put ASCII code into buffer.
mBuffer.append((char) mCommand);
}
return pos;
}
private int parseG1(byte[] data, int pos) {
// For the details of G0 code group, see CEA-708B Section 7.4.4.
// GR Group: G1 ISO 8859-1 Latin 1 Characters
// Put ASCII Extended character set into buffer.
mBuffer.append((char) mCommand);
return pos;
}
// Step 4. Extended code groups
private int parseExt1(byte[] data, int pos) {
// For the details of EXT1 code group, see CEA-708B Section 7.2.
mCommand = data[pos] & 0xff;
++pos;
if (mCommand >= Const.CODE_C2_RANGE_START
&& mCommand <= Const.CODE_C2_RANGE_END) {
pos = parseC2(data, pos);
} else if (mCommand >= Const.CODE_C3_RANGE_START
&& mCommand <= Const.CODE_C3_RANGE_END) {
pos = parseC3(data, pos);
} else if (mCommand >= Const.CODE_G2_RANGE_START
&& mCommand <= Const.CODE_G2_RANGE_END) {
pos = parseG2(data, pos);
} else if (mCommand >= Const.CODE_G3_RANGE_START
&& mCommand <= Const.CODE_G3_RANGE_END) {
pos = parseG3(data ,pos);
}
return pos;
}
private int parseC2(byte[] data, int pos) {
// For the details of C2 code group, see CEA-708B Section 7.4.7.
// Extended Miscellaneous Control Codes
// C2 Table : No commands as of CEA-708B. A decoder must skip.
if (mCommand >= Const.CODE_C2_SKIP0_RANGE_START
&& mCommand <= Const.CODE_C2_SKIP0_RANGE_END) {
// Do nothing.
} else if (mCommand >= Const.CODE_C2_SKIP1_RANGE_START
&& mCommand <= Const.CODE_C2_SKIP1_RANGE_END) {
++pos;
} else if (mCommand >= Const.CODE_C2_SKIP2_RANGE_START
&& mCommand <= Const.CODE_C2_SKIP2_RANGE_END) {
pos += 2;
} else if (mCommand >= Const.CODE_C2_SKIP3_RANGE_START
&& mCommand <= Const.CODE_C2_SKIP3_RANGE_END) {
pos += 3;
}
return pos;
}
private int parseC3(byte[] data, int pos) {
// For the details of C3 code group, see CEA-708B Section 7.4.8.
// Extended Control Code Set 2
// C3 Table : No commands as of CEA-708B. A decoder must skip.
if (mCommand >= Const.CODE_C3_SKIP4_RANGE_START
&& mCommand <= Const.CODE_C3_SKIP4_RANGE_END) {
pos += 4;
} else if (mCommand >= Const.CODE_C3_SKIP5_RANGE_START
&& mCommand <= Const.CODE_C3_SKIP5_RANGE_END) {
pos += 5;
}
return pos;
}
private int parseG2(byte[] data, int pos) {
// For the details of C3 code group, see CEA-708B Section 7.4.5.
// Extended Control Code Set 1(G2 Table)
switch (mCommand) {
case Const.CODE_G2_TSP:
// TODO : TSP is the Transparent space
break;
case Const.CODE_G2_NBTSP:
// TODO : NBTSP is Non-Breaking Transparent Space.
break;
case Const.CODE_G2_BLK:
// TODO : BLK indicates a solid block which fills the entire character block
// TODO : with a solid foreground color.
break;
default:
break;
}
return pos;
}
private int parseG3(byte[] data, int pos) {
// For the details of C3 code group, see CEA-708B Section 7.4.6.
// Future characters and icons(G3 Table)
if (mCommand == Const.CODE_G3_CC) {
// TODO : [CC] icon with square corners
}
// Do nothing
return pos;
}
/**
* @hide
*
* Collection of CEA-708 structures.
*/
private static class Const {
private Const() {
}
// For the details of the ranges of DTVCC code groups, see CEA-708B Table 6.
public static final int CODE_C0_RANGE_START = 0x00;
public static final int CODE_C0_RANGE_END = 0x1f;
public static final int CODE_C1_RANGE_START = 0x80;
public static final int CODE_C1_RANGE_END = 0x9f;
public static final int CODE_G0_RANGE_START = 0x20;
public static final int CODE_G0_RANGE_END = 0x7f;
public static final int CODE_G1_RANGE_START = 0xa0;
public static final int CODE_G1_RANGE_END = 0xff;
public static final int CODE_C2_RANGE_START = 0x00;
public static final int CODE_C2_RANGE_END = 0x1f;
public static final int CODE_C3_RANGE_START = 0x80;
public static final int CODE_C3_RANGE_END = 0x9f;
public static final int CODE_G2_RANGE_START = 0x20;
public static final int CODE_G2_RANGE_END = 0x7f;
public static final int CODE_G3_RANGE_START = 0xa0;
public static final int CODE_G3_RANGE_END = 0xff;
// The following ranges are defined in CEA-708B Section 7.4.1.
public static final int CODE_C0_SKIP2_RANGE_START = 0x18;
public static final int CODE_C0_SKIP2_RANGE_END = 0x1f;
public static final int CODE_C0_SKIP1_RANGE_START = 0x10;
public static final int CODE_C0_SKIP1_RANGE_END = 0x17;
// The following ranges are defined in CEA-708B Section 7.4.7.
public static final int CODE_C2_SKIP0_RANGE_START = 0x00;
public static final int CODE_C2_SKIP0_RANGE_END = 0x07;
public static final int CODE_C2_SKIP1_RANGE_START = 0x08;
public static final int CODE_C2_SKIP1_RANGE_END = 0x0f;
public static final int CODE_C2_SKIP2_RANGE_START = 0x10;
public static final int CODE_C2_SKIP2_RANGE_END = 0x17;
public static final int CODE_C2_SKIP3_RANGE_START = 0x18;
public static final int CODE_C2_SKIP3_RANGE_END = 0x1f;
// The following ranges are defined in CEA-708B Section 7.4.8.
public static final int CODE_C3_SKIP4_RANGE_START = 0x80;
public static final int CODE_C3_SKIP4_RANGE_END = 0x87;
public static final int CODE_C3_SKIP5_RANGE_START = 0x88;
public static final int CODE_C3_SKIP5_RANGE_END = 0x8f;
// The following values are the special characters of CEA-708 spec.
public static final int CODE_C0_NUL = 0x00;
public static final int CODE_C0_ETX = 0x03;
public static final int CODE_C0_BS = 0x08;
public static final int CODE_C0_FF = 0x0c;
public static final int CODE_C0_CR = 0x0d;
public static final int CODE_C0_HCR = 0x0e;
public static final int CODE_C0_EXT1 = 0x10;
public static final int CODE_C0_P16 = 0x18;
public static final int CODE_G0_MUSICNOTE = 0x7f;
public static final int CODE_G2_TSP = 0x20;
public static final int CODE_G2_NBTSP = 0x21;
public static final int CODE_G2_BLK = 0x30;
public static final int CODE_G3_CC = 0xa0;
// The following values are the command bits of CEA-708 spec.
public static final int CODE_C1_CW0 = 0x80;
public static final int CODE_C1_CW1 = 0x81;
public static final int CODE_C1_CW2 = 0x82;
public static final int CODE_C1_CW3 = 0x83;
public static final int CODE_C1_CW4 = 0x84;
public static final int CODE_C1_CW5 = 0x85;
public static final int CODE_C1_CW6 = 0x86;
public static final int CODE_C1_CW7 = 0x87;
public static final int CODE_C1_CLW = 0x88;
public static final int CODE_C1_DSW = 0x89;
public static final int CODE_C1_HDW = 0x8a;
public static final int CODE_C1_TGW = 0x8b;
public static final int CODE_C1_DLW = 0x8c;
public static final int CODE_C1_DLY = 0x8d;
public static final int CODE_C1_DLC = 0x8e;
public static final int CODE_C1_RST = 0x8f;
public static final int CODE_C1_SPA = 0x90;
public static final int CODE_C1_SPC = 0x91;
public static final int CODE_C1_SPL = 0x92;
public static final int CODE_C1_SWA = 0x97;
public static final int CODE_C1_DF0 = 0x98;
public static final int CODE_C1_DF1 = 0x99;
public static final int CODE_C1_DF2 = 0x9a;
public static final int CODE_C1_DF3 = 0x9b;
public static final int CODE_C1_DF4 = 0x9c;
public static final int CODE_C1_DF5 = 0x9d;
public static final int CODE_C1_DF6 = 0x9e;
public static final int CODE_C1_DF7 = 0x9f;
}
/**
* @hide
*
* CEA-708B-specific color.
*/
public static class CaptionColor {
public static final int OPACITY_SOLID = 0;
public static final int OPACITY_FLASH = 1;
public static final int OPACITY_TRANSLUCENT = 2;
public static final int OPACITY_TRANSPARENT = 3;
private static final int[] COLOR_MAP = new int[] { 0x00, 0x0f, 0xf0, 0xff };
private static final int[] OPACITY_MAP = new int[] { 0xff, 0xfe, 0x80, 0x00 };
public final int opacity;
public final int red;
public final int green;
public final int blue;
public CaptionColor(int opacity, int red, int green, int blue) {
this.opacity = opacity;
this.red = red;
this.green = green;
this.blue = blue;
}
public int getArgbValue() {
return Color.argb(
OPACITY_MAP[opacity], COLOR_MAP[red], COLOR_MAP[green], COLOR_MAP[blue]);
}
}
/**
* @hide
*
* Caption event generated by {@link Cea708CCParser}.
*/
public static class CaptionEvent {
public final int type;
public final Object obj;
public CaptionEvent(int type, Object obj) {
this.type = type;
this.obj = obj;
}
}
/**
* @hide
*
* Pen style information.
*/
public static class CaptionPenAttr {
// Pen sizes
public static final int PEN_SIZE_SMALL = 0;
public static final int PEN_SIZE_STANDARD = 1;
public static final int PEN_SIZE_LARGE = 2;
// Offsets
public static final int OFFSET_SUBSCRIPT = 0;
public static final int OFFSET_NORMAL = 1;
public static final int OFFSET_SUPERSCRIPT = 2;
public final int penSize;
public final int penOffset;
public final int textTag;
public final int fontTag;
public final int edgeType;
public final boolean underline;
public final boolean italic;
public CaptionPenAttr(int penSize, int penOffset, int textTag, int fontTag, int edgeType,
boolean underline, boolean italic) {
this.penSize = penSize;
this.penOffset = penOffset;
this.textTag = textTag;
this.fontTag = fontTag;
this.edgeType = edgeType;
this.underline = underline;
this.italic = italic;
}
}
/**
* @hide
*
* {@link CaptionColor} objects that indicate the foreground, background, and edge color of a
* pen.
*/
public static class CaptionPenColor {
public final CaptionColor foregroundColor;
public final CaptionColor backgroundColor;
public final CaptionColor edgeColor;
public CaptionPenColor(CaptionColor foregroundColor, CaptionColor backgroundColor,
CaptionColor edgeColor) {
this.foregroundColor = foregroundColor;
this.backgroundColor = backgroundColor;
this.edgeColor = edgeColor;
}
}
/**
* @hide
*
* Location information of a pen.
*/
public static class CaptionPenLocation {
public final int row;
public final int column;
public CaptionPenLocation(int row, int column) {
this.row = row;
this.column = column;
}
}
/**
* @hide
*
* Attributes of a caption window, which is defined in CEA-708B.
*/
public static class CaptionWindowAttr {
public final CaptionColor fillColor;
public final CaptionColor borderColor;
public final int borderType;
public final boolean wordWrap;
public final int printDirection;
public final int scrollDirection;
public final int justify;
public final int effectDirection;
public final int effectSpeed;
public final int displayEffect;
public CaptionWindowAttr(CaptionColor fillColor, CaptionColor borderColor, int borderType,
boolean wordWrap, int printDirection, int scrollDirection, int justify,
int effectDirection,
int effectSpeed, int displayEffect) {
this.fillColor = fillColor;
this.borderColor = borderColor;
this.borderType = borderType;
this.wordWrap = wordWrap;
this.printDirection = printDirection;
this.scrollDirection = scrollDirection;
this.justify = justify;
this.effectDirection = effectDirection;
this.effectSpeed = effectSpeed;
this.displayEffect = displayEffect;
}
}
/**
* @hide
*
* Construction information of the caption window of CEA-708B.
*/
public static class CaptionWindow {
public final int id;
public final boolean visible;
public final boolean rowLock;
public final boolean columnLock;
public final int priority;
public final boolean relativePositioning;
public final int anchorVertical;
public final int anchorHorizontal;
public final int anchorId;
public final int rowCount;
public final int columnCount;
public final int penStyle;
public final int windowStyle;
public CaptionWindow(int id, boolean visible,
boolean rowLock, boolean columnLock, int priority, boolean relativePositioning,
int anchorVertical, int anchorHorizontal, int anchorId,
int rowCount, int columnCount, int penStyle, int windowStyle) {
this.id = id;
this.visible = visible;
this.rowLock = rowLock;
this.columnLock = columnLock;
this.priority = priority;
this.relativePositioning = relativePositioning;
this.anchorVertical = anchorVertical;
this.anchorHorizontal = anchorHorizontal;
this.anchorId = anchorId;
this.rowCount = rowCount;
this.columnCount = columnCount;
this.penStyle = penStyle;
this.windowStyle = windowStyle;
}
}
}
/**
* Widget capable of rendering CEA-708 closed captions.
*
* @hide
*/
class Cea708CCWidget extends ClosedCaptionWidget implements Cea708CCParser.DisplayListener {
private final CCHandler mCCHandler;
public Cea708CCWidget(Context context) {
this(context, null);
}
public Cea708CCWidget(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
public Cea708CCWidget(Context context, AttributeSet attrs, int defStyleAttr) {
this(context, attrs, defStyleAttr, 0);
}
public Cea708CCWidget(Context context, AttributeSet attrs, int defStyleAttr,
int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
mCCHandler = new CCHandler((CCLayout) mClosedCaptionLayout);
}
@Override
public ClosedCaptionLayout createCaptionLayout(Context context) {
return new CCLayout(context);
}
@Override
public void emitEvent(Cea708CCParser.CaptionEvent event) {
mCCHandler.processCaptionEvent(event);
setSize(getWidth(), getHeight());
if (mListener != null) {
mListener.onChanged(this);
}
}
@Override
public void onDraw(Canvas canvas) {
super.onDraw(canvas);
((ViewGroup) mClosedCaptionLayout).draw(canvas);
}
/**
* @hide
*
* A layout that scales its children using the given percentage value.
*/
static class ScaledLayout extends ViewGroup {
private static final String TAG = "ScaledLayout";
private static final boolean DEBUG = false;
private static final Comparator<Rect> mRectTopLeftSorter = new Comparator<Rect>() {
@Override
public int compare(Rect lhs, Rect rhs) {
if (lhs.top != rhs.top) {
return lhs.top - rhs.top;
} else {
return lhs.left - rhs.left;
}
}
};
private Rect[] mRectArray;
public ScaledLayout(Context context) {
super(context);
}
/**
* @hide
*
* ScaledLayoutParams stores the four scale factors.
* <br>
* Vertical coordinate system: (scaleStartRow * 100) % ~ (scaleEndRow * 100) %
* Horizontal coordinate system: (scaleStartCol * 100) % ~ (scaleEndCol * 100) %
* <br>
* In XML, for example,
* <pre>
* {@code
* <View
* app:layout_scaleStartRow="0.1"
* app:layout_scaleEndRow="0.5"
* app:layout_scaleStartCol="0.4"
* app:layout_scaleEndCol="1" />
* }
* </pre>
*/
static class ScaledLayoutParams extends ViewGroup.LayoutParams {
public static final float SCALE_UNSPECIFIED = -1;
public float scaleStartRow;
public float scaleEndRow;
public float scaleStartCol;
public float scaleEndCol;
public ScaledLayoutParams(float scaleStartRow, float scaleEndRow,
float scaleStartCol, float scaleEndCol) {
super(MATCH_PARENT, MATCH_PARENT);
this.scaleStartRow = scaleStartRow;
this.scaleEndRow = scaleEndRow;
this.scaleStartCol = scaleStartCol;
this.scaleEndCol = scaleEndCol;
}
public ScaledLayoutParams(Context context, AttributeSet attrs) {
super(MATCH_PARENT, MATCH_PARENT);
}
}
@Override
public LayoutParams generateLayoutParams(AttributeSet attrs) {
return new ScaledLayoutParams(getContext(), attrs);
}
@Override
protected boolean checkLayoutParams(LayoutParams p) {
return (p instanceof ScaledLayoutParams);
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int widthSpecSize = MeasureSpec.getSize(widthMeasureSpec);
int heightSpecSize = MeasureSpec.getSize(heightMeasureSpec);
int width = widthSpecSize - getPaddingLeft() - getPaddingRight();
int height = heightSpecSize - getPaddingTop() - getPaddingBottom();
if (DEBUG) {
Log.d(TAG, String.format("onMeasure width: %d, height: %d", width, height));
}
int count = getChildCount();
mRectArray = new Rect[count];
for (int i = 0; i < count; ++i) {
View child = getChildAt(i);
ViewGroup.LayoutParams params = child.getLayoutParams();
float scaleStartRow, scaleEndRow, scaleStartCol, scaleEndCol;
if (!(params instanceof ScaledLayoutParams)) {
throw new RuntimeException(
"A child of ScaledLayout cannot have the UNSPECIFIED scale factors");
}
scaleStartRow = ((ScaledLayoutParams) params).scaleStartRow;
scaleEndRow = ((ScaledLayoutParams) params).scaleEndRow;
scaleStartCol = ((ScaledLayoutParams) params).scaleStartCol;
scaleEndCol = ((ScaledLayoutParams) params).scaleEndCol;
if (scaleStartRow < 0 || scaleStartRow > 1) {
throw new RuntimeException("A child of ScaledLayout should have a range of "
+ "scaleStartRow between 0 and 1");
}
if (scaleEndRow < scaleStartRow || scaleStartRow > 1) {
throw new RuntimeException("A child of ScaledLayout should have a range of "
+ "scaleEndRow between scaleStartRow and 1");
}
if (scaleEndCol < 0 || scaleEndCol > 1) {
throw new RuntimeException("A child of ScaledLayout should have a range of "
+ "scaleStartCol between 0 and 1");
}
if (scaleEndCol < scaleStartCol || scaleEndCol > 1) {
throw new RuntimeException("A child of ScaledLayout should have a range of "
+ "scaleEndCol between scaleStartCol and 1");
}
if (DEBUG) {
Log.d(TAG, String.format("onMeasure child scaleStartRow: %f scaleEndRow: %f "
+ "scaleStartCol: %f scaleEndCol: %f",
scaleStartRow, scaleEndRow, scaleStartCol, scaleEndCol));
}
mRectArray[i] = new Rect((int) (scaleStartCol * width), (int) (scaleStartRow
* height), (int) (scaleEndCol * width), (int) (scaleEndRow * height));
int childWidthSpec = MeasureSpec.makeMeasureSpec(
(int) (width * (scaleEndCol - scaleStartCol)), MeasureSpec.EXACTLY);
int childHeightSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
child.measure(childWidthSpec, childHeightSpec);
// If the height of the measured child view is bigger than the height of the
// calculated region by the given ScaleLayoutParams, the height of the region should
// be increased to fit the size of the child view.
if (child.getMeasuredHeight() > mRectArray[i].height()) {
int overflowedHeight = child.getMeasuredHeight() - mRectArray[i].height();
overflowedHeight = (overflowedHeight + 1) / 2;
mRectArray[i].bottom += overflowedHeight;
mRectArray[i].top -= overflowedHeight;
if (mRectArray[i].top < 0) {
mRectArray[i].bottom -= mRectArray[i].top;
mRectArray[i].top = 0;
}
if (mRectArray[i].bottom > height) {
mRectArray[i].top -= mRectArray[i].bottom - height;
mRectArray[i].bottom = height;
}
}
childHeightSpec = MeasureSpec.makeMeasureSpec(
(int) (height * (scaleEndRow - scaleStartRow)), MeasureSpec.EXACTLY);
child.measure(childWidthSpec, childHeightSpec);
}
// Avoid overlapping rectangles.
// Step 1. Sort rectangles by position (top-left).
int visibleRectCount = 0;
int[] visibleRectGroup = new int[count];
Rect[] visibleRectArray = new Rect[count];
for (int i = 0; i < count; ++i) {
if (getChildAt(i).getVisibility() == View.VISIBLE) {
visibleRectGroup[visibleRectCount] = visibleRectCount;
visibleRectArray[visibleRectCount] = mRectArray[i];
++visibleRectCount;
}
}
Arrays.sort(visibleRectArray, 0, visibleRectCount, mRectTopLeftSorter);
// Step 2. Move down if there are overlapping rectangles.
for (int i = 0; i < visibleRectCount - 1; ++i) {
for (int j = i + 1; j < visibleRectCount; ++j) {
if (Rect.intersects(visibleRectArray[i], visibleRectArray[j])) {
visibleRectGroup[j] = visibleRectGroup[i];
visibleRectArray[j].set(visibleRectArray[j].left,
visibleRectArray[i].bottom,
visibleRectArray[j].right,
visibleRectArray[i].bottom + visibleRectArray[j].height());
}
}
}
// Step 3. Move up if there is any overflowed rectangle.
for (int i = visibleRectCount - 1; i >= 0; --i) {
if (visibleRectArray[i].bottom > height) {
int overflowedHeight = visibleRectArray[i].bottom - height;
for (int j = 0; j <= i; ++j) {
if (visibleRectGroup[i] == visibleRectGroup[j]) {
visibleRectArray[j].set(visibleRectArray[j].left,
visibleRectArray[j].top - overflowedHeight,
visibleRectArray[j].right,
visibleRectArray[j].bottom - overflowedHeight);
}
}
}
}
setMeasuredDimension(widthSpecSize, heightSpecSize);
}
@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
int paddingLeft = getPaddingLeft();
int paddingTop = getPaddingTop();
int count = getChildCount();
for (int i = 0; i < count; ++i) {
View child = getChildAt(i);
if (child.getVisibility() != GONE) {
int childLeft = paddingLeft + mRectArray[i].left;
int childTop = paddingTop + mRectArray[i].top;
int childBottom = paddingLeft + mRectArray[i].bottom;
int childRight = paddingTop + mRectArray[i].right;
if (DEBUG) {
Log.d(TAG, String.format(
"child layout bottom: %d left: %d right: %d top: %d",
childBottom, childLeft, childRight, childTop));
}
child.layout(childLeft, childTop, childRight, childBottom);
}
}
}
@Override
public void dispatchDraw(Canvas canvas) {
int paddingLeft = getPaddingLeft();
int paddingTop = getPaddingTop();
int count = getChildCount();
for (int i = 0; i < count; ++i) {
View child = getChildAt(i);
if (child.getVisibility() != GONE) {
if (i >= mRectArray.length) {
break;
}
int childLeft = paddingLeft + mRectArray[i].left;
int childTop = paddingTop + mRectArray[i].top;
final int saveCount = canvas.save();
canvas.translate(childLeft, childTop);
child.draw(canvas);
canvas.restoreToCount(saveCount);
}
}
}
}
/**
* @hide
*
* Layout containing the safe title area that helps the closed captions look more prominent.
*
* <p>This is required by CEA-708B.
*/
static class CCLayout extends ScaledLayout implements ClosedCaptionLayout {
private static final float SAFE_TITLE_AREA_SCALE_START_X = 0.1f;
private static final float SAFE_TITLE_AREA_SCALE_END_X = 0.9f;
private static final float SAFE_TITLE_AREA_SCALE_START_Y = 0.1f;
private static final float SAFE_TITLE_AREA_SCALE_END_Y = 0.9f;
private final ScaledLayout mSafeTitleAreaLayout;
public CCLayout(Context context) {
super(context);
mSafeTitleAreaLayout = new ScaledLayout(context);
addView(mSafeTitleAreaLayout, new ScaledLayout.ScaledLayoutParams(
SAFE_TITLE_AREA_SCALE_START_X, SAFE_TITLE_AREA_SCALE_END_X,
SAFE_TITLE_AREA_SCALE_START_Y, SAFE_TITLE_AREA_SCALE_END_Y));
}
public void addOrUpdateViewToSafeTitleArea(CCWindowLayout captionWindowLayout,
ScaledLayoutParams scaledLayoutParams) {
int index = mSafeTitleAreaLayout.indexOfChild(captionWindowLayout);
if (index < 0) {
mSafeTitleAreaLayout.addView(captionWindowLayout, scaledLayoutParams);
return;
}
mSafeTitleAreaLayout.updateViewLayout(captionWindowLayout, scaledLayoutParams);
}
public void removeViewFromSafeTitleArea(CCWindowLayout captionWindowLayout) {
mSafeTitleAreaLayout.removeView(captionWindowLayout);
}
public void setCaptionStyle(CaptionStyle style) {
final int count = mSafeTitleAreaLayout.getChildCount();
for (int i = 0; i < count; ++i) {
final CCWindowLayout windowLayout =
(CCWindowLayout) mSafeTitleAreaLayout.getChildAt(i);
windowLayout.setCaptionStyle(style);
}
}
public void setFontScale(float fontScale) {
final int count = mSafeTitleAreaLayout.getChildCount();
for (int i = 0; i < count; ++i) {
final CCWindowLayout windowLayout =
(CCWindowLayout) mSafeTitleAreaLayout.getChildAt(i);
windowLayout.setFontScale(fontScale);
}
}
}
/**
* @hide
*
* Renders the selected CC track.
*/
static class CCHandler implements Handler.Callback {
// TODO: Remaining works
// CaptionTrackRenderer does not support the full spec of CEA-708. The remaining works are
// described in the follows.
// C0 Table: Backspace, FF, and HCR are not supported. The rule for P16 is not standardized
// but it is handled as EUC-KR charset for Korea broadcasting.
// C1 Table: All the styles of windows and pens except underline, italic, pen size, and pen
// offset specified in CEA-708 are ignored and this follows system wide CC
// preferences for look and feel. SetPenLocation is not implemented.
// G2 Table: TSP, NBTSP and BLK are not supported.
// Text/commands: Word wrapping, fonts, row and column locking are not supported.
private static final String TAG = "CCHandler";
private static final boolean DEBUG = false;
private static final int TENTHS_OF_SECOND_IN_MILLIS = 100;
// According to CEA-708B, there can exist up to 8 caption windows.
private static final int CAPTION_WINDOWS_MAX = 8;
private static final int CAPTION_ALL_WINDOWS_BITMAP = 255;
private static final int MSG_DELAY_CANCEL = 1;
private static final int MSG_CAPTION_CLEAR = 2;
private static final long CAPTION_CLEAR_INTERVAL_MS = 60000;
private final CCLayout mCCLayout;
private boolean mIsDelayed = false;
private CCWindowLayout mCurrentWindowLayout;
private final CCWindowLayout[] mCaptionWindowLayouts =
new CCWindowLayout[CAPTION_WINDOWS_MAX];
private final ArrayList<Cea708CCParser.CaptionEvent> mPendingCaptionEvents
= new ArrayList<>();
private final Handler mHandler;
public CCHandler(CCLayout ccLayout) {
mCCLayout = ccLayout;
mHandler = new Handler(this);
}
@Override
public boolean handleMessage(Message msg) {
switch (msg.what) {
case MSG_DELAY_CANCEL:
delayCancel();
return true;
case MSG_CAPTION_CLEAR:
clearWindows(CAPTION_ALL_WINDOWS_BITMAP);
return true;
}
return false;
}
public void processCaptionEvent(Cea708CCParser.CaptionEvent event) {
if (mIsDelayed) {
mPendingCaptionEvents.add(event);
return;
}
switch (event.type) {
case Cea708CCParser.CAPTION_EMIT_TYPE_BUFFER:
sendBufferToCurrentWindow((String) event.obj);
break;
case Cea708CCParser.CAPTION_EMIT_TYPE_CONTROL:
sendControlToCurrentWindow((char) event.obj);
break;
case Cea708CCParser.CAPTION_EMIT_TYPE_COMMAND_CWX:
setCurrentWindowLayout((int) event.obj);
break;
case Cea708CCParser.CAPTION_EMIT_TYPE_COMMAND_CLW:
clearWindows((int) event.obj);
break;
case Cea708CCParser.CAPTION_EMIT_TYPE_COMMAND_DSW:
displayWindows((int) event.obj);
break;
case Cea708CCParser.CAPTION_EMIT_TYPE_COMMAND_HDW:
hideWindows((int) event.obj);
break;
case Cea708CCParser.CAPTION_EMIT_TYPE_COMMAND_TGW:
toggleWindows((int) event.obj);
break;
case Cea708CCParser.CAPTION_EMIT_TYPE_COMMAND_DLW:
deleteWindows((int) event.obj);
break;
case Cea708CCParser.CAPTION_EMIT_TYPE_COMMAND_DLY:
delay((int) event.obj);
break;
case Cea708CCParser.CAPTION_EMIT_TYPE_COMMAND_DLC:
delayCancel();
break;
case Cea708CCParser.CAPTION_EMIT_TYPE_COMMAND_RST:
reset();
break;
case Cea708CCParser.CAPTION_EMIT_TYPE_COMMAND_SPA:
setPenAttr((Cea708CCParser.CaptionPenAttr) event.obj);
break;
case Cea708CCParser.CAPTION_EMIT_TYPE_COMMAND_SPC:
setPenColor((Cea708CCParser.CaptionPenColor) event.obj);
break;
case Cea708CCParser.CAPTION_EMIT_TYPE_COMMAND_SPL:
setPenLocation((Cea708CCParser.CaptionPenLocation) event.obj);
break;
case Cea708CCParser.CAPTION_EMIT_TYPE_COMMAND_SWA:
setWindowAttr((Cea708CCParser.CaptionWindowAttr) event.obj);
break;
case Cea708CCParser.CAPTION_EMIT_TYPE_COMMAND_DFX:
defineWindow((Cea708CCParser.CaptionWindow) event.obj);
break;
}
}
// The window related caption commands
private void setCurrentWindowLayout(int windowId) {
if (windowId < 0 || windowId >= mCaptionWindowLayouts.length) {
return;
}
CCWindowLayout windowLayout = mCaptionWindowLayouts[windowId];
if (windowLayout == null) {
return;
}
if (DEBUG) {
Log.d(TAG, "setCurrentWindowLayout to " + windowId);
}
mCurrentWindowLayout = windowLayout;
}
// Each bit of windowBitmap indicates a window.
// If a bit is set, the window id is the same as the number of the trailing zeros of the
// bit.
private ArrayList<CCWindowLayout> getWindowsFromBitmap(int windowBitmap) {
ArrayList<CCWindowLayout> windows = new ArrayList<>();
for (int i = 0; i < CAPTION_WINDOWS_MAX; ++i) {
if ((windowBitmap & (1 << i)) != 0) {
CCWindowLayout windowLayout = mCaptionWindowLayouts[i];
if (windowLayout != null) {
windows.add(windowLayout);
}
}
}
return windows;
}
private void clearWindows(int windowBitmap) {
if (windowBitmap == 0) {
return;
}
for (CCWindowLayout windowLayout : getWindowsFromBitmap(windowBitmap)) {
windowLayout.clear();
}
}
private void displayWindows(int windowBitmap) {
if (windowBitmap == 0) {
return;
}
for (CCWindowLayout windowLayout : getWindowsFromBitmap(windowBitmap)) {
windowLayout.show();
}
}
private void hideWindows(int windowBitmap) {
if (windowBitmap == 0) {
return;
}
for (CCWindowLayout windowLayout : getWindowsFromBitmap(windowBitmap)) {
windowLayout.hide();
}
}
private void toggleWindows(int windowBitmap) {
if (windowBitmap == 0) {
return;
}
for (CCWindowLayout windowLayout : getWindowsFromBitmap(windowBitmap)) {
if (windowLayout.isShown()) {
windowLayout.hide();
} else {
windowLayout.show();
}
}
}
private void deleteWindows(int windowBitmap) {
if (windowBitmap == 0) {
return;
}
for (CCWindowLayout windowLayout : getWindowsFromBitmap(windowBitmap)) {
windowLayout.removeFromCaptionView();
mCaptionWindowLayouts[windowLayout.getCaptionWindowId()] = null;
}
}
public void reset() {
mCurrentWindowLayout = null;
mIsDelayed = false;
mPendingCaptionEvents.clear();
for (int i = 0; i < CAPTION_WINDOWS_MAX; ++i) {
if (mCaptionWindowLayouts[i] != null) {
mCaptionWindowLayouts[i].removeFromCaptionView();
}
mCaptionWindowLayouts[i] = null;
}
mCCLayout.setVisibility(View.INVISIBLE);
mHandler.removeMessages(MSG_CAPTION_CLEAR);
}
private void setWindowAttr(Cea708CCParser.CaptionWindowAttr windowAttr) {
if (mCurrentWindowLayout != null) {
mCurrentWindowLayout.setWindowAttr(windowAttr);
}
}
private void defineWindow(Cea708CCParser.CaptionWindow window) {
if (window == null) {
return;
}
int windowId = window.id;
if (windowId < 0 || windowId >= mCaptionWindowLayouts.length) {
return;
}
CCWindowLayout windowLayout = mCaptionWindowLayouts[windowId];
if (windowLayout == null) {
windowLayout = new CCWindowLayout(mCCLayout.getContext());
}
windowLayout.initWindow(mCCLayout, window);
mCurrentWindowLayout = mCaptionWindowLayouts[windowId] = windowLayout;
}
// The job related caption commands
private void delay(int tenthsOfSeconds) {
if (tenthsOfSeconds < 0 || tenthsOfSeconds > 255) {
return;
}
mIsDelayed = true;
mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_DELAY_CANCEL),
tenthsOfSeconds * TENTHS_OF_SECOND_IN_MILLIS);
}
private void delayCancel() {
mIsDelayed = false;
processPendingBuffer();
}
private void processPendingBuffer() {
for (Cea708CCParser.CaptionEvent event : mPendingCaptionEvents) {
processCaptionEvent(event);
}
mPendingCaptionEvents.clear();
}
// The implicit write caption commands
private void sendControlToCurrentWindow(char control) {
if (mCurrentWindowLayout != null) {
mCurrentWindowLayout.sendControl(control);
}
}
private void sendBufferToCurrentWindow(String buffer) {
if (mCurrentWindowLayout != null) {
mCurrentWindowLayout.sendBuffer(buffer);
mHandler.removeMessages(MSG_CAPTION_CLEAR);
mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_CAPTION_CLEAR),
CAPTION_CLEAR_INTERVAL_MS);
}
}
// The pen related caption commands
private void setPenAttr(Cea708CCParser.CaptionPenAttr attr) {
if (mCurrentWindowLayout != null) {
mCurrentWindowLayout.setPenAttr(attr);
}
}
private void setPenColor(Cea708CCParser.CaptionPenColor color) {
if (mCurrentWindowLayout != null) {
mCurrentWindowLayout.setPenColor(color);
}
}
private void setPenLocation(Cea708CCParser.CaptionPenLocation location) {
if (mCurrentWindowLayout != null) {
mCurrentWindowLayout.setPenLocation(location.row, location.column);
}
}
}
/**
* @hide
*
* Layout which renders a caption window of CEA-708B. It contains a {@link TextView} that takes
* care of displaying the actual CC text.
*/
static class CCWindowLayout extends RelativeLayout implements View.OnLayoutChangeListener {
private static final String TAG = "CCWindowLayout";
private static final float PROPORTION_PEN_SIZE_SMALL = .75f;
private static final float PROPORTION_PEN_SIZE_LARGE = 1.25f;
// The following values indicates the maximum cell number of a window.
private static final int ANCHOR_RELATIVE_POSITIONING_MAX = 99;
private static final int ANCHOR_VERTICAL_MAX = 74;
private static final int ANCHOR_HORIZONTAL_16_9_MAX = 209;
private static final int MAX_COLUMN_COUNT_16_9 = 42;
// The following values indicates a gravity of a window.
private static final int ANCHOR_MODE_DIVIDER = 3;
private static final int ANCHOR_HORIZONTAL_MODE_LEFT = 0;
private static final int ANCHOR_HORIZONTAL_MODE_CENTER = 1;
private static final int ANCHOR_HORIZONTAL_MODE_RIGHT = 2;
private static final int ANCHOR_VERTICAL_MODE_TOP = 0;
private static final int ANCHOR_VERTICAL_MODE_CENTER = 1;
private static final int ANCHOR_VERTICAL_MODE_BOTTOM = 2;
private CCLayout mCCLayout;
private CCView mCCView;
private CaptionStyle mCaptionStyle;
private int mRowLimit = 0;
private final SpannableStringBuilder mBuilder = new SpannableStringBuilder();
private final List<CharacterStyle> mCharacterStyles = new ArrayList<>();
private int mCaptionWindowId;
private int mRow = -1;
private float mFontScale;
private float mTextSize;
private String mWidestChar;
private int mLastCaptionLayoutWidth;
private int mLastCaptionLayoutHeight;
public CCWindowLayout(Context context) {
this(context, null);
}
public CCWindowLayout(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
public CCWindowLayout(Context context, AttributeSet attrs, int defStyleAttr) {
this(context, attrs, defStyleAttr, 0);
}
public CCWindowLayout(Context context, AttributeSet attrs, int defStyleAttr,
int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
// Add a subtitle view to the layout.
mCCView = new CCView(context);
LayoutParams params = new RelativeLayout.LayoutParams(
ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
addView(mCCView, params);
// Set the system wide CC preferences to the subtitle view.
CaptioningManager captioningManager =
(CaptioningManager) context.getSystemService(Context.CAPTIONING_SERVICE);
mFontScale = captioningManager.getFontScale();
setCaptionStyle(captioningManager.getUserStyle());
mCCView.setText("");
updateWidestChar();
}
public void setCaptionStyle(CaptionStyle style) {
mCaptionStyle = style;
mCCView.setCaptionStyle(style);
}
public void setFontScale(float fontScale) {
mFontScale = fontScale;
updateTextSize();
}
public int getCaptionWindowId() {
return mCaptionWindowId;
}
public void setCaptionWindowId(int captionWindowId) {
mCaptionWindowId = captionWindowId;
}
public void clear() {
clearText();
hide();
}
public void show() {
setVisibility(View.VISIBLE);
requestLayout();
}
public void hide() {
setVisibility(View.INVISIBLE);
requestLayout();
}
public void setPenAttr(Cea708CCParser.CaptionPenAttr penAttr) {
mCharacterStyles.clear();
if (penAttr.italic) {
mCharacterStyles.add(new StyleSpan(Typeface.ITALIC));
}
if (penAttr.underline) {
mCharacterStyles.add(new UnderlineSpan());
}
switch (penAttr.penSize) {
case Cea708CCParser.CaptionPenAttr.PEN_SIZE_SMALL:
mCharacterStyles.add(new RelativeSizeSpan(PROPORTION_PEN_SIZE_SMALL));
break;
case Cea708CCParser.CaptionPenAttr.PEN_SIZE_LARGE:
mCharacterStyles.add(new RelativeSizeSpan(PROPORTION_PEN_SIZE_LARGE));
break;
}
switch (penAttr.penOffset) {
case Cea708CCParser.CaptionPenAttr.OFFSET_SUBSCRIPT:
mCharacterStyles.add(new SubscriptSpan());
break;
case Cea708CCParser.CaptionPenAttr.OFFSET_SUPERSCRIPT:
mCharacterStyles.add(new SuperscriptSpan());
break;
}
}
public void setPenColor(Cea708CCParser.CaptionPenColor penColor) {
// TODO: apply pen colors or skip this and use the style of system wide CC style as is.
}
public void setPenLocation(int row, int column) {
// TODO: change the location of pen based on row and column both.
if (mRow >= 0) {
for (int r = mRow; r < row; ++r) {
appendText("\n");
}
}
mRow = row;
}
public void setWindowAttr(Cea708CCParser.CaptionWindowAttr windowAttr) {
// TODO: apply window attrs or skip this and use the style of system wide CC style as
// is.
}
public void sendBuffer(String buffer) {
appendText(buffer);
}
public void sendControl(char control) {
// TODO: there are a bunch of ASCII-style control codes.
}
/**
* This method places the window on a given CaptionLayout along with the anchor of the
* window.
* <p>
* According to CEA-708B, the anchor id indicates the gravity of the window as the follows.
* For example, A value 7 of a anchor id says that a window is align with its parent bottom
* and is located at the center horizontally of its parent.
* </p>
* <h4>Anchor id and the gravity of a window</h4>
* <table>
* <tr>
* <th>GRAVITY</th>
* <th>LEFT</th>
* <th>CENTER_HORIZONTAL</th>
* <th>RIGHT</th>
* </tr>
* <tr>
* <th>TOP</th>
* <td>0</td>
* <td>1</td>
* <td>2</td>
* </tr>
* <tr>
* <th>CENTER_VERTICAL</th>
* <td>3</td>
* <td>4</td>
* <td>5</td>
* </tr>
* <tr>
* <th>BOTTOM</th>
* <td>6</td>
* <td>7</td>
* <td>8</td>
* </tr>
* </table>
* <p>
* In order to handle the gravity of a window, there are two steps. First, set the size of
* the window. Since the window will be positioned at ScaledLayout, the size factors are
* determined in a ratio. Second, set the gravity of the window. CaptionWindowLayout is
* inherited from RelativeLayout. Hence, we could set the gravity of its child view,
* SubtitleView.
* </p>
* <p>
* The gravity of the window is also related to its size. When it should be pushed to a one
* of the end of the window, like LEFT, RIGHT, TOP or BOTTOM, the anchor point should be a
* boundary of the window. When it should be pushed in the horizontal/vertical center of its
* container, the horizontal/vertical center point of the window should be the same as the
* anchor point.
* </p>
*
* @param ccLayout a given CaptionLayout, which contains a safe title area.
* @param captionWindow a given CaptionWindow, which stores the construction info of the
* window.
*/
public void initWindow(CCLayout ccLayout, Cea708CCParser.CaptionWindow captionWindow) {
if (mCCLayout != ccLayout) {
if (mCCLayout != null) {
mCCLayout.removeOnLayoutChangeListener(this);
}
mCCLayout = ccLayout;
mCCLayout.addOnLayoutChangeListener(this);
updateWidestChar();
}
// Both anchor vertical and horizontal indicates the position cell number of the window.
float scaleRow = (float) captionWindow.anchorVertical /
(captionWindow.relativePositioning
? ANCHOR_RELATIVE_POSITIONING_MAX : ANCHOR_VERTICAL_MAX);
// Assumes it has a wide aspect ratio track.
float scaleCol = (float) captionWindow.anchorHorizontal /
(captionWindow.relativePositioning ? ANCHOR_RELATIVE_POSITIONING_MAX
: ANCHOR_HORIZONTAL_16_9_MAX);
// The range of scaleRow/Col need to be verified to be in [0, 1].
// Otherwise a RuntimeException will be raised in ScaledLayout.
if (scaleRow < 0 || scaleRow > 1) {
Log.i(TAG, "The vertical position of the anchor point should be at the range of 0 "
+ "and 1 but " + scaleRow);
scaleRow = Math.max(0, Math.min(scaleRow, 1));
}
if (scaleCol < 0 || scaleCol > 1) {
Log.i(TAG, "The horizontal position of the anchor point should be at the range of 0"
+ " and 1 but " + scaleCol);
scaleCol = Math.max(0, Math.min(scaleCol, 1));
}
int gravity = Gravity.CENTER;
int horizontalMode = captionWindow.anchorId % ANCHOR_MODE_DIVIDER;
int verticalMode = captionWindow.anchorId / ANCHOR_MODE_DIVIDER;
float scaleStartRow = 0;
float scaleEndRow = 1;
float scaleStartCol = 0;
float scaleEndCol = 1;
switch (horizontalMode) {
case ANCHOR_HORIZONTAL_MODE_LEFT:
gravity = Gravity.LEFT;
mCCView.setAlignment(Alignment.ALIGN_NORMAL);
scaleStartCol = scaleCol;
break;
case ANCHOR_HORIZONTAL_MODE_CENTER:
float gap = Math.min(1 - scaleCol, scaleCol);
// Since all TV sets use left text alignment instead of center text alignment
// for this case, we follow the industry convention if possible.
int columnCount = captionWindow.columnCount + 1;
columnCount = Math.min(getScreenColumnCount(), columnCount);
StringBuilder widestTextBuilder = new StringBuilder();
for (int i = 0; i < columnCount; ++i) {
widestTextBuilder.append(mWidestChar);
}
Paint paint = new Paint();
paint.setTypeface(mCaptionStyle.getTypeface());
paint.setTextSize(mTextSize);
float maxWindowWidth = paint.measureText(widestTextBuilder.toString());
float halfMaxWidthScale = mCCLayout.getWidth() > 0
? maxWindowWidth / 2.0f / (mCCLayout.getWidth() * 0.8f) : 0.0f;
if (halfMaxWidthScale > 0f && halfMaxWidthScale < scaleCol) {
// Calculate the expected max window size based on the column count of the
// caption window multiplied by average alphabets char width, then align the
// left side of the window with the left side of the expected max window.
gravity = Gravity.LEFT;
mCCView.setAlignment(Alignment.ALIGN_NORMAL);
scaleStartCol = scaleCol - halfMaxWidthScale;
scaleEndCol = 1.0f;
} else {
// The gap will be the minimum distance value of the distances from both
// horizontal end points to the anchor point.
// If scaleCol <= 0.5, the range of scaleCol is [0, the anchor point * 2].
// If scaleCol > 0.5, the range of scaleCol is
// [(1 - the anchor point) * 2, 1].
// The anchor point is located at the horizontal center of the window in
// both cases.
gravity = Gravity.CENTER_HORIZONTAL;
mCCView.setAlignment(Alignment.ALIGN_CENTER);
scaleStartCol = scaleCol - gap;
scaleEndCol = scaleCol + gap;
}
break;
case ANCHOR_HORIZONTAL_MODE_RIGHT:
gravity = Gravity.RIGHT;
mCCView.setAlignment(Alignment.ALIGN_RIGHT);
scaleEndCol = scaleCol;
break;
}
switch (verticalMode) {
case ANCHOR_VERTICAL_MODE_TOP:
gravity |= Gravity.TOP;
scaleStartRow = scaleRow;
break;
case ANCHOR_VERTICAL_MODE_CENTER:
gravity |= Gravity.CENTER_VERTICAL;
// See the above comment.
float gap = Math.min(1 - scaleRow, scaleRow);
scaleStartRow = scaleRow - gap;
scaleEndRow = scaleRow + gap;
break;
case ANCHOR_VERTICAL_MODE_BOTTOM:
gravity |= Gravity.BOTTOM;
scaleEndRow = scaleRow;
break;
}
mCCLayout.addOrUpdateViewToSafeTitleArea(this, new ScaledLayout
.ScaledLayoutParams(scaleStartRow, scaleEndRow, scaleStartCol, scaleEndCol));
setCaptionWindowId(captionWindow.id);
setRowLimit(captionWindow.rowCount);
setGravity(gravity);
if (captionWindow.visible) {
show();
} else {
hide();
}
}
@Override
public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft,
int oldTop, int oldRight, int oldBottom) {
int width = right - left;
int height = bottom - top;
if (width != mLastCaptionLayoutWidth || height != mLastCaptionLayoutHeight) {
mLastCaptionLayoutWidth = width;
mLastCaptionLayoutHeight = height;
updateTextSize();
}
}
private void updateWidestChar() {
Paint paint = new Paint();
paint.setTypeface(mCaptionStyle.getTypeface());
Charset latin1 = Charset.forName("ISO-8859-1");
float widestCharWidth = 0f;
for (int i = 0; i < 256; ++i) {
String ch = new String(new byte[]{(byte) i}, latin1);
float charWidth = paint.measureText(ch);
if (widestCharWidth < charWidth) {
widestCharWidth = charWidth;
mWidestChar = ch;
}
}
updateTextSize();
}
private void updateTextSize() {
if (mCCLayout == null) return;
// Calculate text size based on the max window size.
StringBuilder widestTextBuilder = new StringBuilder();
int screenColumnCount = getScreenColumnCount();
for (int i = 0; i < screenColumnCount; ++i) {
widestTextBuilder.append(mWidestChar);
}
String widestText = widestTextBuilder.toString();
Paint paint = new Paint();
paint.setTypeface(mCaptionStyle.getTypeface());
float startFontSize = 0f;
float endFontSize = 255f;
while (startFontSize < endFontSize) {
float testTextSize = (startFontSize + endFontSize) / 2f;
paint.setTextSize(testTextSize);
float width = paint.measureText(widestText);
if (mCCLayout.getWidth() * 0.8f > width) {
startFontSize = testTextSize + 0.01f;
} else {
endFontSize = testTextSize - 0.01f;
}
}
mTextSize = endFontSize * mFontScale;
mCCView.setTextSize(mTextSize);
}
private int getScreenColumnCount() {
// Assume it has a wide aspect ratio track.
return MAX_COLUMN_COUNT_16_9;
}
public void removeFromCaptionView() {
if (mCCLayout != null) {
mCCLayout.removeViewFromSafeTitleArea(this);
mCCLayout.removeOnLayoutChangeListener(this);
mCCLayout = null;
}
}
public void setText(String text) {
updateText(text, false);
}
public void appendText(String text) {
updateText(text, true);
}
public void clearText() {
mBuilder.clear();
mCCView.setText("");
}
private void updateText(String text, boolean appended) {
if (!appended) {
mBuilder.clear();
}
if (text != null && text.length() > 0) {
int length = mBuilder.length();
mBuilder.append(text);
for (CharacterStyle characterStyle : mCharacterStyles) {
mBuilder.setSpan(characterStyle, length, mBuilder.length(),
Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
}
}
String[] lines = TextUtils.split(mBuilder.toString(), "\n");
// Truncate text not to exceed the row limit.
// Plus one here since the range of the rows is [0, mRowLimit].
String truncatedText = TextUtils.join("\n", Arrays.copyOfRange(
lines, Math.max(0, lines.length - (mRowLimit + 1)), lines.length));
mBuilder.delete(0, mBuilder.length() - truncatedText.length());
// Trim the buffer first then set text to CCView.
int start = 0, last = mBuilder.length() - 1;
int end = last;
while ((start <= end) && (mBuilder.charAt(start) <= ' ')) {
++start;
}
while ((end >= start) && (mBuilder.charAt(end) <= ' ')) {
--end;
}
if (start == 0 && end == last) {
mCCView.setText(mBuilder);
} else {
SpannableStringBuilder trim = new SpannableStringBuilder();
trim.append(mBuilder);
if (end < last) {
trim.delete(end + 1, last + 1);
}
if (start > 0) {
trim.delete(0, start);
}
mCCView.setText(trim);
}
}
public void setRowLimit(int rowLimit) {
if (rowLimit < 0) {
throw new IllegalArgumentException("A rowLimit should have a positive number");
}
mRowLimit = rowLimit;
}
}
/** @hide */
static class CCView extends SubtitleView {
private static final CaptionStyle DEFAULT_CAPTION_STYLE = CaptionStyle.DEFAULT;
public CCView(Context context) {
this(context, null);
}
public CCView(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
public CCView(Context context, AttributeSet attrs, int defStyleAttr) {
this(context, attrs, defStyleAttr, 0);
}
public CCView(Context context, AttributeSet attrs, int defStyleAttr,
int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
}
public void setCaptionStyle(CaptionStyle style) {
setForegroundColor(style.hasForegroundColor()
? style.foregroundColor : DEFAULT_CAPTION_STYLE.foregroundColor);
setBackgroundColor(style.hasBackgroundColor()
? style.backgroundColor : DEFAULT_CAPTION_STYLE.backgroundColor);
setEdgeType(style.hasEdgeType()
? style.edgeType : DEFAULT_CAPTION_STYLE.edgeType);
setEdgeColor(style.hasEdgeColor()
? style.edgeColor : DEFAULT_CAPTION_STYLE.edgeColor);
setTypeface(style.getTypeface());
}
}
}