1 /* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.media; 18 19 import android.content.Context; 20 import android.content.res.Resources; 21 import android.graphics.Canvas; 22 import android.graphics.Color; 23 import android.graphics.Paint; 24 import android.graphics.Rect; 25 import android.graphics.Typeface; 26 import android.text.Spannable; 27 import android.text.SpannableStringBuilder; 28 import android.text.TextPaint; 29 import android.text.style.CharacterStyle; 30 import android.text.style.StyleSpan; 31 import android.text.style.UnderlineSpan; 32 import android.text.style.UpdateAppearance; 33 import android.util.AttributeSet; 34 import android.util.Log; 35 import android.util.TypedValue; 36 import android.view.Gravity; 37 import android.view.View; 38 import android.view.ViewGroup; 39 import android.view.accessibility.CaptioningManager; 40 import android.view.accessibility.CaptioningManager.CaptionStyle; 41 import android.view.accessibility.CaptioningManager.CaptioningChangeListener; 42 import android.widget.LinearLayout; 43 import android.widget.TextView; 44 45 import java.util.ArrayList; 46 import java.util.Arrays; 47 import java.util.Vector; 48 49 /** @hide */ 50 public class ClosedCaptionRenderer extends SubtitleController.Renderer { 51 private final Context mContext; 52 private Cea608CCWidget mCCWidget; 53 54 public ClosedCaptionRenderer(Context context) { 55 mContext = context; 56 } 57 58 @Override 59 public boolean supports(MediaFormat format) { 60 if (format.containsKey(MediaFormat.KEY_MIME)) { 61 String mimeType = format.getString(MediaFormat.KEY_MIME); 62 return MediaPlayer.MEDIA_MIMETYPE_TEXT_CEA_608.equals(mimeType); 63 } 64 return false; 65 } 66 67 @Override 68 public SubtitleTrack createTrack(MediaFormat format) { 69 String mimeType = format.getString(MediaFormat.KEY_MIME); 70 if (MediaPlayer.MEDIA_MIMETYPE_TEXT_CEA_608.equals(mimeType)) { 71 if (mCCWidget == null) { 72 mCCWidget = new Cea608CCWidget(mContext); 73 } 74 return new Cea608CaptionTrack(mCCWidget, format); 75 } 76 throw new RuntimeException("No matching format: " + format.toString()); 77 } 78 } 79 80 /** @hide */ 81 class Cea608CaptionTrack extends SubtitleTrack { 82 private final Cea608CCParser mCCParser; 83 private final Cea608CCWidget mRenderingWidget; 84 85 Cea608CaptionTrack(Cea608CCWidget renderingWidget, MediaFormat format) { 86 super(format); 87 88 mRenderingWidget = renderingWidget; 89 mCCParser = new Cea608CCParser(mRenderingWidget); 90 } 91 92 @Override 93 public void onData(byte[] data, boolean eos, long runID) { 94 mCCParser.parse(data); 95 } 96 97 @Override 98 public RenderingWidget getRenderingWidget() { 99 return mRenderingWidget; 100 } 101 102 @Override 103 public void updateView(Vector<Cue> activeCues) { 104 // Overriding with NO-OP, CC rendering by-passes this 105 } 106 } 107 108 /** 109 * Abstract widget class to render a closed caption track. 110 * 111 * @hide 112 */ 113 abstract class ClosedCaptionWidget extends ViewGroup implements SubtitleTrack.RenderingWidget { 114 115 /** @hide */ 116 interface ClosedCaptionLayout { 117 void setCaptionStyle(CaptionStyle captionStyle); 118 void setFontScale(float scale); 119 } 120 121 private static final CaptionStyle DEFAULT_CAPTION_STYLE = CaptionStyle.DEFAULT; 122 123 /** Captioning manager, used to obtain and track caption properties. */ 124 private final CaptioningManager mManager; 125 126 /** Current caption style. */ 127 protected CaptionStyle mCaptionStyle; 128 129 /** Callback for rendering changes. */ 130 protected OnChangedListener mListener; 131 132 /** Concrete layout of CC. */ 133 protected ClosedCaptionLayout mClosedCaptionLayout; 134 135 /** Whether a caption style change listener is registered. */ 136 private boolean mHasChangeListener; 137 138 public ClosedCaptionWidget(Context context) { 139 this(context, null); 140 } 141 142 public ClosedCaptionWidget(Context context, AttributeSet attrs) { 143 this(context, attrs, 0); 144 } 145 146 public ClosedCaptionWidget(Context context, AttributeSet attrs, int defStyle) { 147 this(context, attrs, defStyle, 0); 148 } 149 150 public ClosedCaptionWidget(Context context, AttributeSet attrs, int defStyleAttr, 151 int defStyleRes) { 152 super(context, attrs, defStyleAttr, defStyleRes); 153 154 // Cannot render text over video when layer type is hardware. 155 setLayerType(View.LAYER_TYPE_SOFTWARE, null); 156 157 mManager = (CaptioningManager) context.getSystemService(Context.CAPTIONING_SERVICE); 158 mCaptionStyle = DEFAULT_CAPTION_STYLE.applyStyle(mManager.getUserStyle()); 159 160 mClosedCaptionLayout = createCaptionLayout(context); 161 mClosedCaptionLayout.setCaptionStyle(mCaptionStyle); 162 mClosedCaptionLayout.setFontScale(mManager.getFontScale()); 163 addView((ViewGroup) mClosedCaptionLayout, LayoutParams.MATCH_PARENT, 164 LayoutParams.MATCH_PARENT); 165 166 requestLayout(); 167 } 168 169 public abstract ClosedCaptionLayout createCaptionLayout(Context context); 170 171 @Override 172 public void setOnChangedListener(OnChangedListener listener) { 173 mListener = listener; 174 } 175 176 @Override 177 public void setSize(int width, int height) { 178 final int widthSpec = MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY); 179 final int heightSpec = MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY); 180 181 measure(widthSpec, heightSpec); 182 layout(0, 0, width, height); 183 } 184 185 @Override 186 public void setVisible(boolean visible) { 187 if (visible) { 188 setVisibility(View.VISIBLE); 189 } else { 190 setVisibility(View.GONE); 191 } 192 193 manageChangeListener(); 194 } 195 196 @Override 197 public void onAttachedToWindow() { 198 super.onAttachedToWindow(); 199 200 manageChangeListener(); 201 } 202 203 @Override 204 public void onDetachedFromWindow() { 205 super.onDetachedFromWindow(); 206 207 manageChangeListener(); 208 } 209 210 @Override 211 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 212 super.onMeasure(widthMeasureSpec, heightMeasureSpec); 213 ((ViewGroup) mClosedCaptionLayout).measure(widthMeasureSpec, heightMeasureSpec); 214 } 215 216 @Override 217 protected void onLayout(boolean changed, int l, int t, int r, int b) { 218 ((ViewGroup) mClosedCaptionLayout).layout(l, t, r, b); 219 } 220 221 /** 222 * Manages whether this renderer is listening for caption style changes. 223 */ 224 private final CaptioningChangeListener mCaptioningListener = new CaptioningChangeListener() { 225 @Override 226 public void onUserStyleChanged(CaptionStyle userStyle) { 227 mCaptionStyle = DEFAULT_CAPTION_STYLE.applyStyle(userStyle); 228 mClosedCaptionLayout.setCaptionStyle(mCaptionStyle); 229 } 230 231 @Override 232 public void onFontScaleChanged(float fontScale) { 233 mClosedCaptionLayout.setFontScale(fontScale); 234 } 235 }; 236 237 private void manageChangeListener() { 238 final boolean needsListener = isAttachedToWindow() && getVisibility() == View.VISIBLE; 239 if (mHasChangeListener != needsListener) { 240 mHasChangeListener = needsListener; 241 242 if (needsListener) { 243 mManager.addCaptioningChangeListener(mCaptioningListener); 244 } else { 245 mManager.removeCaptioningChangeListener(mCaptioningListener); 246 } 247 } 248 } 249 } 250 251 /** 252 * @hide 253 * 254 * CCParser processes CEA-608 closed caption data. 255 * 256 * It calls back into OnDisplayChangedListener upon 257 * display change with styled text for rendering. 258 * 259 */ 260 class Cea608CCParser { 261 public static final int MAX_ROWS = 15; 262 public static final int MAX_COLS = 32; 263 264 private static final String TAG = "Cea608CCParser"; 265 private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG); 266 267 private static final int INVALID = -1; 268 269 // EIA-CEA-608: Table 70 - Control Codes 270 private static final int RCL = 0x20; 271 private static final int BS = 0x21; 272 private static final int AOF = 0x22; 273 private static final int AON = 0x23; 274 private static final int DER = 0x24; 275 private static final int RU2 = 0x25; 276 private static final int RU3 = 0x26; 277 private static final int RU4 = 0x27; 278 private static final int FON = 0x28; 279 private static final int RDC = 0x29; 280 private static final int TR = 0x2a; 281 private static final int RTD = 0x2b; 282 private static final int EDM = 0x2c; 283 private static final int CR = 0x2d; 284 private static final int ENM = 0x2e; 285 private static final int EOC = 0x2f; 286 287 // Transparent Space 288 private static final char TS = '\u00A0'; 289 290 // Captioning Modes 291 private static final int MODE_UNKNOWN = 0; 292 private static final int MODE_PAINT_ON = 1; 293 private static final int MODE_ROLL_UP = 2; 294 private static final int MODE_POP_ON = 3; 295 private static final int MODE_TEXT = 4; 296 297 private final DisplayListener mListener; 298 299 private int mMode = MODE_PAINT_ON; 300 private int mRollUpSize = 4; 301 private int mPrevCtrlCode = INVALID; 302 303 private CCMemory mDisplay = new CCMemory(); 304 private CCMemory mNonDisplay = new CCMemory(); 305 private CCMemory mTextMem = new CCMemory(); 306 307 Cea608CCParser(DisplayListener listener) { 308 mListener = listener; 309 } 310 311 public void parse(byte[] data) { 312 CCData[] ccData = CCData.fromByteArray(data); 313 314 for (int i = 0; i < ccData.length; i++) { 315 if (DEBUG) { 316 Log.d(TAG, ccData[i].toString()); 317 } 318 319 if (handleCtrlCode(ccData[i]) 320 || handleTabOffsets(ccData[i]) 321 || handlePACCode(ccData[i]) 322 || handleMidRowCode(ccData[i])) { 323 continue; 324 } 325 326 handleDisplayableChars(ccData[i]); 327 } 328 } 329 330 interface DisplayListener { 331 void onDisplayChanged(SpannableStringBuilder[] styledTexts); 332 CaptionStyle getCaptionStyle(); 333 } 334 335 private CCMemory getMemory() { 336 // get the CC memory to operate on for current mode 337 switch (mMode) { 338 case MODE_POP_ON: 339 return mNonDisplay; 340 case MODE_TEXT: 341 // TODO(chz): support only caption mode for now, 342 // in text mode, dump everything to text mem. 343 return mTextMem; 344 case MODE_PAINT_ON: 345 case MODE_ROLL_UP: 346 return mDisplay; 347 default: 348 Log.w(TAG, "unrecoginized mode: " + mMode); 349 } 350 return mDisplay; 351 } 352 353 private boolean handleDisplayableChars(CCData ccData) { 354 if (!ccData.isDisplayableChar()) { 355 return false; 356 } 357 358 // Extended char includes 1 automatic backspace 359 if (ccData.isExtendedChar()) { 360 getMemory().bs(); 361 } 362 363 getMemory().writeText(ccData.getDisplayText()); 364 365 if (mMode == MODE_PAINT_ON || mMode == MODE_ROLL_UP) { 366 updateDisplay(); 367 } 368 369 return true; 370 } 371 372 private boolean handleMidRowCode(CCData ccData) { 373 StyleCode m = ccData.getMidRow(); 374 if (m != null) { 375 getMemory().writeMidRowCode(m); 376 return true; 377 } 378 return false; 379 } 380 381 private boolean handlePACCode(CCData ccData) { 382 PAC pac = ccData.getPAC(); 383 384 if (pac != null) { 385 if (mMode == MODE_ROLL_UP) { 386 getMemory().moveBaselineTo(pac.getRow(), mRollUpSize); 387 } 388 getMemory().writePAC(pac); 389 return true; 390 } 391 392 return false; 393 } 394 395 private boolean handleTabOffsets(CCData ccData) { 396 int tabs = ccData.getTabOffset(); 397 398 if (tabs > 0) { 399 getMemory().tab(tabs); 400 return true; 401 } 402 403 return false; 404 } 405 406 private boolean handleCtrlCode(CCData ccData) { 407 int ctrlCode = ccData.getCtrlCode(); 408 409 if (mPrevCtrlCode != INVALID && mPrevCtrlCode == ctrlCode) { 410 // discard double ctrl codes (but if there's a 3rd one, we still take that) 411 mPrevCtrlCode = INVALID; 412 return true; 413 } 414 415 switch(ctrlCode) { 416 case RCL: 417 // select pop-on style 418 mMode = MODE_POP_ON; 419 break; 420 case BS: 421 getMemory().bs(); 422 break; 423 case DER: 424 getMemory().der(); 425 break; 426 case RU2: 427 case RU3: 428 case RU4: 429 mRollUpSize = (ctrlCode - 0x23); 430 // erase memory if currently in other style 431 if (mMode != MODE_ROLL_UP) { 432 mDisplay.erase(); 433 mNonDisplay.erase(); 434 } 435 // select roll-up style 436 mMode = MODE_ROLL_UP; 437 break; 438 case FON: 439 Log.i(TAG, "Flash On"); 440 break; 441 case RDC: 442 // select paint-on style 443 mMode = MODE_PAINT_ON; 444 break; 445 case TR: 446 mMode = MODE_TEXT; 447 mTextMem.erase(); 448 break; 449 case RTD: 450 mMode = MODE_TEXT; 451 break; 452 case EDM: 453 // erase display memory 454 mDisplay.erase(); 455 updateDisplay(); 456 break; 457 case CR: 458 if (mMode == MODE_ROLL_UP) { 459 getMemory().rollUp(mRollUpSize); 460 } else { 461 getMemory().cr(); 462 } 463 if (mMode == MODE_ROLL_UP) { 464 updateDisplay(); 465 } 466 break; 467 case ENM: 468 // erase non-display memory 469 mNonDisplay.erase(); 470 break; 471 case EOC: 472 // swap display/non-display memory 473 swapMemory(); 474 // switch to pop-on style 475 mMode = MODE_POP_ON; 476 updateDisplay(); 477 break; 478 case INVALID: 479 default: 480 mPrevCtrlCode = INVALID; 481 return false; 482 } 483 484 mPrevCtrlCode = ctrlCode; 485 486 // handled 487 return true; 488 } 489 490 private void updateDisplay() { 491 if (mListener != null) { 492 CaptionStyle captionStyle = mListener.getCaptionStyle(); 493 mListener.onDisplayChanged(mDisplay.getStyledText(captionStyle)); 494 } 495 } 496 497 private void swapMemory() { 498 CCMemory temp = mDisplay; 499 mDisplay = mNonDisplay; 500 mNonDisplay = temp; 501 } 502 503 private static class StyleCode { 504 static final int COLOR_WHITE = 0; 505 static final int COLOR_GREEN = 1; 506 static final int COLOR_BLUE = 2; 507 static final int COLOR_CYAN = 3; 508 static final int COLOR_RED = 4; 509 static final int COLOR_YELLOW = 5; 510 static final int COLOR_MAGENTA = 6; 511 static final int COLOR_INVALID = 7; 512 513 static final int STYLE_ITALICS = 0x00000001; 514 static final int STYLE_UNDERLINE = 0x00000002; 515 516 static final String[] mColorMap = { 517 "WHITE", "GREEN", "BLUE", "CYAN", "RED", "YELLOW", "MAGENTA", "INVALID" 518 }; 519 520 final int mStyle; 521 final int mColor; 522 523 static StyleCode fromByte(byte data2) { 524 int style = 0; 525 int color = (data2 >> 1) & 0x7; 526 527 if ((data2 & 0x1) != 0) { 528 style |= STYLE_UNDERLINE; 529 } 530 531 if (color == COLOR_INVALID) { 532 // WHITE ITALICS 533 color = COLOR_WHITE; 534 style |= STYLE_ITALICS; 535 } 536 537 return new StyleCode(style, color); 538 } 539 540 StyleCode(int style, int color) { 541 mStyle = style; 542 mColor = color; 543 } 544 545 boolean isItalics() { 546 return (mStyle & STYLE_ITALICS) != 0; 547 } 548 549 boolean isUnderline() { 550 return (mStyle & STYLE_UNDERLINE) != 0; 551 } 552 553 int getColor() { 554 return mColor; 555 } 556 557 @Override 558 public String toString() { 559 StringBuilder str = new StringBuilder(); 560 str.append("{"); 561 str.append(mColorMap[mColor]); 562 if ((mStyle & STYLE_ITALICS) != 0) { 563 str.append(", ITALICS"); 564 } 565 if ((mStyle & STYLE_UNDERLINE) != 0) { 566 str.append(", UNDERLINE"); 567 } 568 str.append("}"); 569 570 return str.toString(); 571 } 572 } 573 574 private static class PAC extends StyleCode { 575 final int mRow; 576 final int mCol; 577 578 static PAC fromBytes(byte data1, byte data2) { 579 int[] rowTable = {11, 1, 3, 12, 14, 5, 7, 9}; 580 int row = rowTable[data1 & 0x07] + ((data2 & 0x20) >> 5); 581 int style = 0; 582 if ((data2 & 1) != 0) { 583 style |= STYLE_UNDERLINE; 584 } 585 if ((data2 & 0x10) != 0) { 586 // indent code 587 int indent = (data2 >> 1) & 0x7; 588 return new PAC(row, indent * 4, style, COLOR_WHITE); 589 } else { 590 // style code 591 int color = (data2 >> 1) & 0x7; 592 593 if (color == COLOR_INVALID) { 594 // WHITE ITALICS 595 color = COLOR_WHITE; 596 style |= STYLE_ITALICS; 597 } 598 return new PAC(row, -1, style, color); 599 } 600 } 601 602 PAC(int row, int col, int style, int color) { 603 super(style, color); 604 mRow = row; 605 mCol = col; 606 } 607 608 boolean isIndentPAC() { 609 return (mCol >= 0); 610 } 611 612 int getRow() { 613 return mRow; 614 } 615 616 int getCol() { 617 return mCol; 618 } 619 620 @Override 621 public String toString() { 622 return String.format("{%d, %d}, %s", 623 mRow, mCol, super.toString()); 624 } 625 } 626 627 /** 628 * Mutable version of BackgroundSpan to facilitate text rendering with edge styles. 629 * 630 * @hide 631 */ 632 public static class MutableBackgroundColorSpan extends CharacterStyle 633 implements UpdateAppearance { 634 private int mColor; 635 636 public MutableBackgroundColorSpan(int color) { 637 mColor = color; 638 } 639 640 public void setBackgroundColor(int color) { 641 mColor = color; 642 } 643 644 public int getBackgroundColor() { 645 return mColor; 646 } 647 648 @Override 649 public void updateDrawState(TextPaint ds) { 650 ds.bgColor = mColor; 651 } 652 } 653 654 /* CCLineBuilder keeps track of displayable chars, as well as 655 * MidRow styles and PACs, for a single line of CC memory. 656 * 657 * It generates styled text via getStyledText() method. 658 */ 659 private static class CCLineBuilder { 660 private final StringBuilder mDisplayChars; 661 private final StyleCode[] mMidRowStyles; 662 private final StyleCode[] mPACStyles; 663 664 CCLineBuilder(String str) { 665 mDisplayChars = new StringBuilder(str); 666 mMidRowStyles = new StyleCode[mDisplayChars.length()]; 667 mPACStyles = new StyleCode[mDisplayChars.length()]; 668 } 669 670 void setCharAt(int index, char ch) { 671 mDisplayChars.setCharAt(index, ch); 672 mMidRowStyles[index] = null; 673 } 674 675 void setMidRowAt(int index, StyleCode m) { 676 mDisplayChars.setCharAt(index, ' '); 677 mMidRowStyles[index] = m; 678 } 679 680 void setPACAt(int index, PAC pac) { 681 mPACStyles[index] = pac; 682 } 683 684 char charAt(int index) { 685 return mDisplayChars.charAt(index); 686 } 687 688 int length() { 689 return mDisplayChars.length(); 690 } 691 692 void applyStyleSpan( 693 SpannableStringBuilder styledText, 694 StyleCode s, int start, int end) { 695 if (s.isItalics()) { 696 styledText.setSpan( 697 new StyleSpan(android.graphics.Typeface.ITALIC), 698 start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); 699 } 700 if (s.isUnderline()) { 701 styledText.setSpan( 702 new UnderlineSpan(), 703 start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); 704 } 705 } 706 707 SpannableStringBuilder getStyledText(CaptionStyle captionStyle) { 708 SpannableStringBuilder styledText = new SpannableStringBuilder(mDisplayChars); 709 int start = -1, next = 0; 710 int styleStart = -1; 711 StyleCode curStyle = null; 712 while (next < mDisplayChars.length()) { 713 StyleCode newStyle = null; 714 if (mMidRowStyles[next] != null) { 715 // apply mid-row style change 716 newStyle = mMidRowStyles[next]; 717 } else if (mPACStyles[next] != null 718 && (styleStart < 0 || start < 0)) { 719 // apply PAC style change, only if: 720 // 1. no style set, or 721 // 2. style set, but prev char is none-displayable 722 newStyle = mPACStyles[next]; 723 } 724 if (newStyle != null) { 725 curStyle = newStyle; 726 if (styleStart >= 0 && start >= 0) { 727 applyStyleSpan(styledText, newStyle, styleStart, next); 728 } 729 styleStart = next; 730 } 731 732 if (mDisplayChars.charAt(next) != TS) { 733 if (start < 0) { 734 start = next; 735 } 736 } else if (start >= 0) { 737 int expandedStart = mDisplayChars.charAt(start) == ' ' ? start : start - 1; 738 int expandedEnd = mDisplayChars.charAt(next - 1) == ' ' ? next : next + 1; 739 styledText.setSpan( 740 new MutableBackgroundColorSpan(captionStyle.backgroundColor), 741 expandedStart, expandedEnd, 742 Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); 743 if (styleStart >= 0) { 744 applyStyleSpan(styledText, curStyle, styleStart, expandedEnd); 745 } 746 start = -1; 747 } 748 next++; 749 } 750 751 return styledText; 752 } 753 } 754 755 /* 756 * CCMemory models a console-style display. 757 */ 758 private static class CCMemory { 759 private final String mBlankLine; 760 private final CCLineBuilder[] mLines = new CCLineBuilder[MAX_ROWS + 2]; 761 private int mRow; 762 private int mCol; 763 764 CCMemory() { 765 char[] blank = new char[MAX_COLS + 2]; 766 Arrays.fill(blank, TS); 767 mBlankLine = new String(blank); 768 } 769 770 void erase() { 771 // erase all lines 772 for (int i = 0; i < mLines.length; i++) { 773 mLines[i] = null; 774 } 775 mRow = MAX_ROWS; 776 mCol = 1; 777 } 778 779 void der() { 780 if (mLines[mRow] != null) { 781 for (int i = 0; i < mCol; i++) { 782 if (mLines[mRow].charAt(i) != TS) { 783 for (int j = mCol; j < mLines[mRow].length(); j++) { 784 mLines[j].setCharAt(j, TS); 785 } 786 return; 787 } 788 } 789 mLines[mRow] = null; 790 } 791 } 792 793 void tab(int tabs) { 794 moveCursorByCol(tabs); 795 } 796 797 void bs() { 798 moveCursorByCol(-1); 799 if (mLines[mRow] != null) { 800 mLines[mRow].setCharAt(mCol, TS); 801 if (mCol == MAX_COLS - 1) { 802 // Spec recommendation: 803 // if cursor was at col 32, move cursor 804 // back to col 31 and erase both col 31&32 805 mLines[mRow].setCharAt(MAX_COLS, TS); 806 } 807 } 808 } 809 810 void cr() { 811 moveCursorTo(mRow + 1, 1); 812 } 813 814 void rollUp(int windowSize) { 815 int i; 816 for (i = 0; i <= mRow - windowSize; i++) { 817 mLines[i] = null; 818 } 819 int startRow = mRow - windowSize + 1; 820 if (startRow < 1) { 821 startRow = 1; 822 } 823 for (i = startRow; i < mRow; i++) { 824 mLines[i] = mLines[i + 1]; 825 } 826 for (i = mRow; i < mLines.length; i++) { 827 // clear base row 828 mLines[i] = null; 829 } 830 // default to col 1, in case PAC is not sent 831 mCol = 1; 832 } 833 834 void writeText(String text) { 835 for (int i = 0; i < text.length(); i++) { 836 getLineBuffer(mRow).setCharAt(mCol, text.charAt(i)); 837 moveCursorByCol(1); 838 } 839 } 840 841 void writeMidRowCode(StyleCode m) { 842 getLineBuffer(mRow).setMidRowAt(mCol, m); 843 moveCursorByCol(1); 844 } 845 846 void writePAC(PAC pac) { 847 if (pac.isIndentPAC()) { 848 moveCursorTo(pac.getRow(), pac.getCol()); 849 } else { 850 moveCursorTo(pac.getRow(), 1); 851 } 852 getLineBuffer(mRow).setPACAt(mCol, pac); 853 } 854 855 SpannableStringBuilder[] getStyledText(CaptionStyle captionStyle) { 856 ArrayList<SpannableStringBuilder> rows = new ArrayList<>(MAX_ROWS); 857 for (int i = 1; i <= MAX_ROWS; i++) { 858 rows.add(mLines[i] != null ? 859 mLines[i].getStyledText(captionStyle) : null); 860 } 861 return rows.toArray(new SpannableStringBuilder[MAX_ROWS]); 862 } 863 864 private static int clamp(int x, int min, int max) { 865 return x < min ? min : (x > max ? max : x); 866 } 867 868 private void moveCursorTo(int row, int col) { 869 mRow = clamp(row, 1, MAX_ROWS); 870 mCol = clamp(col, 1, MAX_COLS); 871 } 872 873 private void moveCursorToRow(int row) { 874 mRow = clamp(row, 1, MAX_ROWS); 875 } 876 877 private void moveCursorByCol(int col) { 878 mCol = clamp(mCol + col, 1, MAX_COLS); 879 } 880 881 private void moveBaselineTo(int baseRow, int windowSize) { 882 if (mRow == baseRow) { 883 return; 884 } 885 int actualWindowSize = windowSize; 886 if (baseRow < actualWindowSize) { 887 actualWindowSize = baseRow; 888 } 889 if (mRow < actualWindowSize) { 890 actualWindowSize = mRow; 891 } 892 893 int i; 894 if (baseRow < mRow) { 895 // copy from bottom to top row 896 for (i = actualWindowSize - 1; i >= 0; i--) { 897 mLines[baseRow - i] = mLines[mRow - i]; 898 } 899 } else { 900 // copy from top to bottom row 901 for (i = 0; i < actualWindowSize; i++) { 902 mLines[baseRow - i] = mLines[mRow - i]; 903 } 904 } 905 // clear rest of the rows 906 for (i = 0; i <= baseRow - windowSize; i++) { 907 mLines[i] = null; 908 } 909 for (i = baseRow + 1; i < mLines.length; i++) { 910 mLines[i] = null; 911 } 912 } 913 914 private CCLineBuilder getLineBuffer(int row) { 915 if (mLines[row] == null) { 916 mLines[row] = new CCLineBuilder(mBlankLine); 917 } 918 return mLines[row]; 919 } 920 } 921 922 /* 923 * CCData parses the raw CC byte pair into displayable chars, 924 * misc control codes, Mid-Row or Preamble Address Codes. 925 */ 926 private static class CCData { 927 private final byte mType; 928 private final byte mData1; 929 private final byte mData2; 930 931 private static final String[] mCtrlCodeMap = { 932 "RCL", "BS" , "AOF", "AON", 933 "DER", "RU2", "RU3", "RU4", 934 "FON", "RDC", "TR" , "RTD", 935 "EDM", "CR" , "ENM", "EOC", 936 }; 937 938 private static final String[] mSpecialCharMap = { 939 "\u00AE", 940 "\u00B0", 941 "\u00BD", 942 "\u00BF", 943 "\u2122", 944 "\u00A2", 945 "\u00A3", 946 "\u266A", // Eighth note 947 "\u00E0", 948 "\u00A0", // Transparent space 949 "\u00E8", 950 "\u00E2", 951 "\u00EA", 952 "\u00EE", 953 "\u00F4", 954 "\u00FB", 955 }; 956 957 private static final String[] mSpanishCharMap = { 958 // Spanish and misc chars 959 "\u00C1", // A 960 "\u00C9", // E 961 "\u00D3", // I 962 "\u00DA", // O 963 "\u00DC", // U 964 "\u00FC", // u 965 "\u2018", // opening single quote 966 "\u00A1", // inverted exclamation mark 967 "*", 968 "'", 969 "\u2014", // em dash 970 "\u00A9", // Copyright 971 "\u2120", // Servicemark 972 "\u2022", // round bullet 973 "\u201C", // opening double quote 974 "\u201D", // closing double quote 975 // French 976 "\u00C0", 977 "\u00C2", 978 "\u00C7", 979 "\u00C8", 980 "\u00CA", 981 "\u00CB", 982 "\u00EB", 983 "\u00CE", 984 "\u00CF", 985 "\u00EF", 986 "\u00D4", 987 "\u00D9", 988 "\u00F9", 989 "\u00DB", 990 "\u00AB", 991 "\u00BB" 992 }; 993 994 private static final String[] mProtugueseCharMap = { 995 // Portuguese 996 "\u00C3", 997 "\u00E3", 998 "\u00CD", 999 "\u00CC", 1000 "\u00EC", 1001 "\u00D2", 1002 "\u00F2", 1003 "\u00D5", 1004 "\u00F5", 1005 "{", 1006 "}", 1007 "\\", 1008 "^", 1009 "_", 1010 "|", 1011 "~", 1012 // German and misc chars 1013 "\u00C4", 1014 "\u00E4", 1015 "\u00D6", 1016 "\u00F6", 1017 "\u00DF", 1018 "\u00A5", 1019 "\u00A4", 1020 "\u2502", // vertical bar 1021 "\u00C5", 1022 "\u00E5", 1023 "\u00D8", 1024 "\u00F8", 1025 "\u250C", // top-left corner 1026 "\u2510", // top-right corner 1027 "\u2514", // lower-left corner 1028 "\u2518", // lower-right corner 1029 }; 1030 1031 static CCData[] fromByteArray(byte[] data) { 1032 CCData[] ccData = new CCData[data.length / 3]; 1033 1034 for (int i = 0; i < ccData.length; i++) { 1035 ccData[i] = new CCData( 1036 data[i * 3], 1037 data[i * 3 + 1], 1038 data[i * 3 + 2]); 1039 } 1040 1041 return ccData; 1042 } 1043 1044 CCData(byte type, byte data1, byte data2) { 1045 mType = type; 1046 mData1 = data1; 1047 mData2 = data2; 1048 } 1049 1050 int getCtrlCode() { 1051 if ((mData1 == 0x14 || mData1 == 0x1c) 1052 && mData2 >= 0x20 && mData2 <= 0x2f) { 1053 return mData2; 1054 } 1055 return INVALID; 1056 } 1057 1058 StyleCode getMidRow() { 1059 // only support standard Mid-row codes, ignore 1060 // optional background/foreground mid-row codes 1061 if ((mData1 == 0x11 || mData1 == 0x19) 1062 && mData2 >= 0x20 && mData2 <= 0x2f) { 1063 return StyleCode.fromByte(mData2); 1064 } 1065 return null; 1066 } 1067 1068 PAC getPAC() { 1069 if ((mData1 & 0x70) == 0x10 1070 && (mData2 & 0x40) == 0x40 1071 && ((mData1 & 0x07) != 0 || (mData2 & 0x20) == 0)) { 1072 return PAC.fromBytes(mData1, mData2); 1073 } 1074 return null; 1075 } 1076 1077 int getTabOffset() { 1078 if ((mData1 == 0x17 || mData1 == 0x1f) 1079 && mData2 >= 0x21 && mData2 <= 0x23) { 1080 return mData2 & 0x3; 1081 } 1082 return 0; 1083 } 1084 1085 boolean isDisplayableChar() { 1086 return isBasicChar() || isSpecialChar() || isExtendedChar(); 1087 } 1088 1089 String getDisplayText() { 1090 String str = getBasicChars(); 1091 1092 if (str == null) { 1093 str = getSpecialChar(); 1094 1095 if (str == null) { 1096 str = getExtendedChar(); 1097 } 1098 } 1099 1100 return str; 1101 } 1102 1103 private String ctrlCodeToString(int ctrlCode) { 1104 return mCtrlCodeMap[ctrlCode - 0x20]; 1105 } 1106 1107 private boolean isBasicChar() { 1108 return mData1 >= 0x20 && mData1 <= 0x7f; 1109 } 1110 1111 private boolean isSpecialChar() { 1112 return ((mData1 == 0x11 || mData1 == 0x19) 1113 && mData2 >= 0x30 && mData2 <= 0x3f); 1114 } 1115 1116 private boolean isExtendedChar() { 1117 return ((mData1 == 0x12 || mData1 == 0x1A 1118 || mData1 == 0x13 || mData1 == 0x1B) 1119 && mData2 >= 0x20 && mData2 <= 0x3f); 1120 } 1121 1122 private char getBasicChar(byte data) { 1123 char c; 1124 // replace the non-ASCII ones 1125 switch (data) { 1126 case 0x2A: c = '\u00E1'; break; 1127 case 0x5C: c = '\u00E9'; break; 1128 case 0x5E: c = '\u00ED'; break; 1129 case 0x5F: c = '\u00F3'; break; 1130 case 0x60: c = '\u00FA'; break; 1131 case 0x7B: c = '\u00E7'; break; 1132 case 0x7C: c = '\u00F7'; break; 1133 case 0x7D: c = '\u00D1'; break; 1134 case 0x7E: c = '\u00F1'; break; 1135 case 0x7F: c = '\u2588'; break; // Full block 1136 default: c = (char) data; break; 1137 } 1138 return c; 1139 } 1140 1141 private String getBasicChars() { 1142 if (mData1 >= 0x20 && mData1 <= 0x7f) { 1143 StringBuilder builder = new StringBuilder(2); 1144 builder.append(getBasicChar(mData1)); 1145 if (mData2 >= 0x20 && mData2 <= 0x7f) { 1146 builder.append(getBasicChar(mData2)); 1147 } 1148 return builder.toString(); 1149 } 1150 1151 return null; 1152 } 1153 1154 private String getSpecialChar() { 1155 if ((mData1 == 0x11 || mData1 == 0x19) 1156 && mData2 >= 0x30 && mData2 <= 0x3f) { 1157 return mSpecialCharMap[mData2 - 0x30]; 1158 } 1159 1160 return null; 1161 } 1162 1163 private String getExtendedChar() { 1164 if ((mData1 == 0x12 || mData1 == 0x1A) 1165 && mData2 >= 0x20 && mData2 <= 0x3f){ 1166 // 1 Spanish/French char 1167 return mSpanishCharMap[mData2 - 0x20]; 1168 } else if ((mData1 == 0x13 || mData1 == 0x1B) 1169 && mData2 >= 0x20 && mData2 <= 0x3f){ 1170 // 1 Portuguese/German/Danish char 1171 return mProtugueseCharMap[mData2 - 0x20]; 1172 } 1173 1174 return null; 1175 } 1176 1177 @Override 1178 public String toString() { 1179 String str; 1180 1181 if (mData1 < 0x10 && mData2 < 0x10) { 1182 // Null Pad, ignore 1183 return String.format("[%d]Null: %02x %02x", mType, mData1, mData2); 1184 } 1185 1186 int ctrlCode = getCtrlCode(); 1187 if (ctrlCode != INVALID) { 1188 return String.format("[%d]%s", mType, ctrlCodeToString(ctrlCode)); 1189 } 1190 1191 int tabOffset = getTabOffset(); 1192 if (tabOffset > 0) { 1193 return String.format("[%d]Tab%d", mType, tabOffset); 1194 } 1195 1196 PAC pac = getPAC(); 1197 if (pac != null) { 1198 return String.format("[%d]PAC: %s", mType, pac.toString()); 1199 } 1200 1201 StyleCode m = getMidRow(); 1202 if (m != null) { 1203 return String.format("[%d]Mid-row: %s", mType, m.toString()); 1204 } 1205 1206 if (isDisplayableChar()) { 1207 return String.format("[%d]Displayable: %s (%02x %02x)", 1208 mType, getDisplayText(), mData1, mData2); 1209 } 1210 1211 return String.format("[%d]Invalid: %02x %02x", mType, mData1, mData2); 1212 } 1213 } 1214 } 1215 1216 /** 1217 * Widget capable of rendering CEA-608 closed captions. 1218 * 1219 * @hide 1220 */ 1221 class Cea608CCWidget extends ClosedCaptionWidget implements Cea608CCParser.DisplayListener { 1222 private static final Rect mTextBounds = new Rect(); 1223 private static final String mDummyText = "1234567890123456789012345678901234"; 1224 1225 public Cea608CCWidget(Context context) { 1226 this(context, null); 1227 } 1228 1229 public Cea608CCWidget(Context context, AttributeSet attrs) { 1230 this(context, attrs, 0); 1231 } 1232 1233 public Cea608CCWidget(Context context, AttributeSet attrs, int defStyle) { 1234 this(context, attrs, defStyle, 0); 1235 } 1236 1237 public Cea608CCWidget(Context context, AttributeSet attrs, int defStyleAttr, 1238 int defStyleRes) { 1239 super(context, attrs, defStyleAttr, defStyleRes); 1240 } 1241 1242 @Override 1243 public ClosedCaptionLayout createCaptionLayout(Context context) { 1244 return new CCLayout(context); 1245 } 1246 1247 @Override 1248 public void onDisplayChanged(SpannableStringBuilder[] styledTexts) { 1249 ((CCLayout) mClosedCaptionLayout).update(styledTexts); 1250 1251 if (mListener != null) { 1252 mListener.onChanged(this); 1253 } 1254 } 1255 1256 @Override 1257 public CaptionStyle getCaptionStyle() { 1258 return mCaptionStyle; 1259 } 1260 1261 private static class CCLineBox extends TextView { 1262 private static final float FONT_PADDING_RATIO = 0.75f; 1263 private static final float EDGE_OUTLINE_RATIO = 0.1f; 1264 private static final float EDGE_SHADOW_RATIO = 0.05f; 1265 private float mOutlineWidth; 1266 private float mShadowRadius; 1267 private float mShadowOffset; 1268 1269 private int mTextColor = Color.WHITE; 1270 private int mBgColor = Color.BLACK; 1271 private int mEdgeType = CaptionStyle.EDGE_TYPE_NONE; 1272 private int mEdgeColor = Color.TRANSPARENT; 1273 1274 CCLineBox(Context context) { 1275 super(context); 1276 setGravity(Gravity.CENTER); 1277 setBackgroundColor(Color.TRANSPARENT); 1278 setTextColor(Color.WHITE); 1279 setTypeface(Typeface.MONOSPACE); 1280 setVisibility(View.INVISIBLE); 1281 1282 final Resources res = getContext().getResources(); 1283 1284 // get the default (will be updated later during measure) 1285 mOutlineWidth = res.getDimensionPixelSize( 1286 com.android.internal.R.dimen.subtitle_outline_width); 1287 mShadowRadius = res.getDimensionPixelSize( 1288 com.android.internal.R.dimen.subtitle_shadow_radius); 1289 mShadowOffset = res.getDimensionPixelSize( 1290 com.android.internal.R.dimen.subtitle_shadow_offset); 1291 } 1292 1293 void setCaptionStyle(CaptionStyle captionStyle) { 1294 mTextColor = captionStyle.foregroundColor; 1295 mBgColor = captionStyle.backgroundColor; 1296 mEdgeType = captionStyle.edgeType; 1297 mEdgeColor = captionStyle.edgeColor; 1298 1299 setTextColor(mTextColor); 1300 if (mEdgeType == CaptionStyle.EDGE_TYPE_DROP_SHADOW) { 1301 setShadowLayer(mShadowRadius, mShadowOffset, mShadowOffset, mEdgeColor); 1302 } else { 1303 setShadowLayer(0, 0, 0, 0); 1304 } 1305 invalidate(); 1306 } 1307 1308 @Override 1309 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 1310 float fontSize = MeasureSpec.getSize(heightMeasureSpec) * FONT_PADDING_RATIO; 1311 setTextSize(TypedValue.COMPLEX_UNIT_PX, fontSize); 1312 1313 mOutlineWidth = EDGE_OUTLINE_RATIO * fontSize + 1.0f; 1314 mShadowRadius = EDGE_SHADOW_RATIO * fontSize + 1.0f;; 1315 mShadowOffset = mShadowRadius; 1316 1317 // set font scale in the X direction to match the required width 1318 setScaleX(1.0f); 1319 getPaint().getTextBounds(mDummyText, 0, mDummyText.length(), mTextBounds); 1320 float actualTextWidth = mTextBounds.width(); 1321 float requiredTextWidth = MeasureSpec.getSize(widthMeasureSpec); 1322 setScaleX(requiredTextWidth / actualTextWidth); 1323 1324 super.onMeasure(widthMeasureSpec, heightMeasureSpec); 1325 } 1326 1327 @Override 1328 protected void onDraw(Canvas c) { 1329 if (mEdgeType == CaptionStyle.EDGE_TYPE_UNSPECIFIED 1330 || mEdgeType == CaptionStyle.EDGE_TYPE_NONE 1331 || mEdgeType == CaptionStyle.EDGE_TYPE_DROP_SHADOW) { 1332 // these edge styles don't require a second pass 1333 super.onDraw(c); 1334 return; 1335 } 1336 1337 if (mEdgeType == CaptionStyle.EDGE_TYPE_OUTLINE) { 1338 drawEdgeOutline(c); 1339 } else { 1340 // Raised or depressed 1341 drawEdgeRaisedOrDepressed(c); 1342 } 1343 } 1344 1345 private void drawEdgeOutline(Canvas c) { 1346 TextPaint textPaint = getPaint(); 1347 1348 Paint.Style previousStyle = textPaint.getStyle(); 1349 Paint.Join previousJoin = textPaint.getStrokeJoin(); 1350 float previousWidth = textPaint.getStrokeWidth(); 1351 1352 setTextColor(mEdgeColor); 1353 textPaint.setStyle(Paint.Style.FILL_AND_STROKE); 1354 textPaint.setStrokeJoin(Paint.Join.ROUND); 1355 textPaint.setStrokeWidth(mOutlineWidth); 1356 1357 // Draw outline and background only. 1358 super.onDraw(c); 1359 1360 // Restore original settings. 1361 setTextColor(mTextColor); 1362 textPaint.setStyle(previousStyle); 1363 textPaint.setStrokeJoin(previousJoin); 1364 textPaint.setStrokeWidth(previousWidth); 1365 1366 // Remove the background. 1367 setBackgroundSpans(Color.TRANSPARENT); 1368 // Draw foreground only. 1369 super.onDraw(c); 1370 // Restore the background. 1371 setBackgroundSpans(mBgColor); 1372 } 1373 1374 private void drawEdgeRaisedOrDepressed(Canvas c) { 1375 TextPaint textPaint = getPaint(); 1376 1377 Paint.Style previousStyle = textPaint.getStyle(); 1378 textPaint.setStyle(Paint.Style.FILL); 1379 1380 final boolean raised = mEdgeType == CaptionStyle.EDGE_TYPE_RAISED; 1381 final int colorUp = raised ? Color.WHITE : mEdgeColor; 1382 final int colorDown = raised ? mEdgeColor : Color.WHITE; 1383 final float offset = mShadowRadius / 2f; 1384 1385 // Draw background and text with shadow up 1386 setShadowLayer(mShadowRadius, -offset, -offset, colorUp); 1387 super.onDraw(c); 1388 1389 // Remove the background. 1390 setBackgroundSpans(Color.TRANSPARENT); 1391 1392 // Draw text with shadow down 1393 setShadowLayer(mShadowRadius, +offset, +offset, colorDown); 1394 super.onDraw(c); 1395 1396 // Restore settings 1397 textPaint.setStyle(previousStyle); 1398 1399 // Restore the background. 1400 setBackgroundSpans(mBgColor); 1401 } 1402 1403 private void setBackgroundSpans(int color) { 1404 CharSequence text = getText(); 1405 if (text instanceof Spannable) { 1406 Spannable spannable = (Spannable) text; 1407 Cea608CCParser.MutableBackgroundColorSpan[] bgSpans = spannable.getSpans( 1408 0, spannable.length(), Cea608CCParser.MutableBackgroundColorSpan.class); 1409 for (int i = 0; i < bgSpans.length; i++) { 1410 bgSpans[i].setBackgroundColor(color); 1411 } 1412 } 1413 } 1414 } 1415 1416 private static class CCLayout extends LinearLayout implements ClosedCaptionLayout { 1417 private static final int MAX_ROWS = Cea608CCParser.MAX_ROWS; 1418 private static final float SAFE_AREA_RATIO = 0.9f; 1419 1420 private final CCLineBox[] mLineBoxes = new CCLineBox[MAX_ROWS]; 1421 1422 CCLayout(Context context) { 1423 super(context); 1424 setGravity(Gravity.START); 1425 setOrientation(LinearLayout.VERTICAL); 1426 for (int i = 0; i < MAX_ROWS; i++) { 1427 mLineBoxes[i] = new CCLineBox(getContext()); 1428 addView(mLineBoxes[i], LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT); 1429 } 1430 } 1431 1432 @Override 1433 public void setCaptionStyle(CaptionStyle captionStyle) { 1434 for (int i = 0; i < MAX_ROWS; i++) { 1435 mLineBoxes[i].setCaptionStyle(captionStyle); 1436 } 1437 } 1438 1439 @Override 1440 public void setFontScale(float fontScale) { 1441 // Ignores the font scale changes of the system wide CC preference. 1442 } 1443 1444 void update(SpannableStringBuilder[] textBuffer) { 1445 for (int i = 0; i < MAX_ROWS; i++) { 1446 if (textBuffer[i] != null) { 1447 mLineBoxes[i].setText(textBuffer[i], TextView.BufferType.SPANNABLE); 1448 mLineBoxes[i].setVisibility(View.VISIBLE); 1449 } else { 1450 mLineBoxes[i].setVisibility(View.INVISIBLE); 1451 } 1452 } 1453 } 1454 1455 @Override 1456 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 1457 super.onMeasure(widthMeasureSpec, heightMeasureSpec); 1458 1459 int safeWidth = getMeasuredWidth(); 1460 int safeHeight = getMeasuredHeight(); 1461 1462 // CEA-608 assumes 4:3 video 1463 if (safeWidth * 3 >= safeHeight * 4) { 1464 safeWidth = safeHeight * 4 / 3; 1465 } else { 1466 safeHeight = safeWidth * 3 / 4; 1467 } 1468 safeWidth *= SAFE_AREA_RATIO; 1469 safeHeight *= SAFE_AREA_RATIO; 1470 1471 int lineHeight = safeHeight / MAX_ROWS; 1472 int lineHeightMeasureSpec = MeasureSpec.makeMeasureSpec( 1473 lineHeight, MeasureSpec.EXACTLY); 1474 int lineWidthMeasureSpec = MeasureSpec.makeMeasureSpec( 1475 safeWidth, MeasureSpec.EXACTLY); 1476 1477 for (int i = 0; i < MAX_ROWS; i++) { 1478 mLineBoxes[i].measure(lineWidthMeasureSpec, lineHeightMeasureSpec); 1479 } 1480 } 1481 1482 @Override 1483 protected void onLayout(boolean changed, int l, int t, int r, int b) { 1484 // safe caption area 1485 int viewPortWidth = r - l; 1486 int viewPortHeight = b - t; 1487 int safeWidth, safeHeight; 1488 // CEA-608 assumes 4:3 video 1489 if (viewPortWidth * 3 >= viewPortHeight * 4) { 1490 safeWidth = viewPortHeight * 4 / 3; 1491 safeHeight = viewPortHeight; 1492 } else { 1493 safeWidth = viewPortWidth; 1494 safeHeight = viewPortWidth * 3 / 4; 1495 } 1496 safeWidth *= SAFE_AREA_RATIO; 1497 safeHeight *= SAFE_AREA_RATIO; 1498 int left = (viewPortWidth - safeWidth) / 2; 1499 int top = (viewPortHeight - safeHeight) / 2; 1500 1501 for (int i = 0; i < MAX_ROWS; i++) { 1502 mLineBoxes[i].layout( 1503 left, 1504 top + safeHeight * i / MAX_ROWS, 1505 left + safeWidth, 1506 top + safeHeight * (i + 1) / MAX_ROWS); 1507 } 1508 } 1509 } 1510 } 1511
