@quicktvui/ai 1.0.8 → 1.0.9

package/rules/.source/sdk/support/subtitle-converter/src/main/java/com/quicktvui/support/subtitle/converter/subtitleFile/FormatVTT.java

@@ -0,0 +1,227 @@
+package com.quicktvui.support.subtitle.converter.subtitleFile;
+
+import android.text.TextUtils;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+
+public class FormatVTT implements TimedTextFileFormat {
+
+    public TimedTextObject parseFile(String fileName, InputStream is) throws IOException {
+        return parseFile(fileName, is, Charset.defaultCharset());
+    }
+
+    public TimedTextObject parseFile(String fileName, InputStream is, Charset isCharset) throws IOException {
+
+        TimedTextObject tto = new TimedTextObject();
+        Caption caption = new Caption();
+        int captionNumber = 1;
+        boolean allGood;
+
+        //first lets load the file
+        InputStreamReader in = new InputStreamReader(is, isCharset);
+        BufferedReader br = new BufferedReader(in);
+
+        //the file name is saved
+        tto.fileName = fileName;
+
+        String line = br.readLine();
+        if (line != null){
+            line = line.replace("\uFEFF", ""); //remove BOM character
+        }
+        int lineCounter = 0;
+        if (!line.equals("WEBVTT")) {
+            tto.warnings = "not a vtt file";
+            tto.built = true;
+            return tto;
+        }
+        line = br.readLine();
+        if (line != null && line.isEmpty()) {
+            line = br.readLine();
+        }
+        try {
+            while (line != null) {
+                line = line.trim();
+                lineCounter++;
+                //if its a blank line, ignore it, otherwise...
+                if (!line.isEmpty()) {
+                    allGood = true;
+                    //the first thing should be an increasing number
+//                    try {
+//                        int num = Integer.parseInt(line);
+//                        if (num != captionNumber)
+//                            throw new Exception();
+//                        else {
+//                            captionNumber++;
+//                            allGood = true;
+//                        }
+//                    } catch (Exception e) {
+//                        tto.warnings += captionNumber + " expected at line " + lineCounter;
+//                        tto.warnings += "\n skipping to next line\n\n";
+//                    }
+                    if (allGood) {
+                        //we go to next line, here the begin and end time should be found
+                        try {
+//                            lineCounter++;
+//                            line = br.readLine().trim();
+                            boolean timeTag = true;
+                            String start = line.substring(0, 12);
+                            if (start.contains(":")) {
+                                if (start.split(":").length < 3) {
+                                    //mm:ss
+                                    start = line.substring(0, 9);
+                                    timeTag = false;
+                                }
+                            }
+                            String end;
+                            Time time;
+                            if (timeTag) {
+                                end = line.substring(line.length() - 12, line.length());
+                                time = new Time("hh:mm:ss,ms", start);
+                                caption.start = time;
+                                time = new Time("hh:mm:ss,ms", end);
+                            } else {
+                                time = new Time("hh:mm:ss,ms", "00:" + start);
+                                caption.start = time;
+                                end = line.substring(9, line.length());
+                                if (end.contains(":") && end.split(":").length < 3) {
+                                    end = line.substring(line.length() - 9, line.length());
+                                } else {
+                                    end = line.substring(line.length() - 12, line.length());
+                                }
+                                if (end.contains(":") && end.split(":").length < 3) {
+                                    //mm:ss
+                                    time = new Time("hh:mm:ss,ms", "00:" + end);
+                                } else {
+                                    time = new Time("hh:mm:ss,ms", end);
+                                }
+                            }
+                            caption.end = time;
+
+                        } catch (Exception e) {
+                            tto.warnings += "incorrect time format at line " + lineCounter;
+                            allGood = false;
+                        }
+                    }
+                    if (allGood) {
+                        //we go to next line where the caption text starts
+                        lineCounter++;
+                        line = br.readLine().trim();
+                        String text = "";
+                        while (!line.isEmpty()) {
+                            text += line + "\n";
+                            line = br.readLine().trim();
+                            lineCounter++;
+                        }
+                        if (!TextUtils.isEmpty(text)) {
+                            if (text.contains("\n")) {
+                                String lastTwoChar = text.substring(text.length() - 1);
+                                if (lastTwoChar.equals("\n")) {
+                                    text = text.substring(0, text.length() - 1);
+                                }
+                            }
+                        }
+                        caption.content = text;
+                        int key = caption.start.mseconds;
+                        //in case the key is already there, we increase it by a millisecond, since no duplicates are allowed
+                        while (tto.captions.containsKey(key)) key++;
+                        if (key != caption.start.mseconds)
+                            tto.warnings += "caption with same start time found...\n\n";
+                        //we add the caption.
+                        tto.captions.put(key, caption);
+                    }
+                    //we go to next blank
+                    while (!line.isEmpty()) {
+                        line = br.readLine().trim();
+                        lineCounter++;
+                    }
+                    caption = new Caption();
+                }
+                line = br.readLine();
+            }
+
+        } catch (NullPointerException e) {
+            tto.warnings += "unexpected end of file, maybe last caption is not complete.\n\n";
+        } finally {
+            //we close the reader
+            is.close();
+        }
+
+        tto.built = true;
+        return tto;
+    }
+
+
+    public String[] toFile(TimedTextObject tto) {
+
+        //first we check if the TimedTextObject had been built, otherwise...
+        if (!tto.built)
+            return null;
+
+        //we will write the lines in an ArrayList,
+        int index = 0;
+        //the minimum size of the file is 4*number of captions, so we'll take some extra space.
+        ArrayList<String> file = new ArrayList<>(5 * tto.captions.size());
+        //we iterate over our captions collection, they are ordered since they come from a TreeMap
+        Collection<Caption> c = tto.captions.values();
+        Iterator<Caption> itr = c.iterator();
+        int captionNumber = 1;
+
+        while (itr.hasNext()) {
+            //new caption
+            Caption current = itr.next();
+            //number is written
+            file.add(index++, Integer.toString(captionNumber++));
+            //we check for offset value:
+            if (tto.offset != 0) {
+                current.start.mseconds += tto.offset;
+                current.end.mseconds += tto.offset;
+            }
+            //time is written
+            file.add(index++, current.start.getTime("hh:mm:ss,ms") + " --> " + current.end.getTime("hh:mm:ss,ms"));
+            //offset is undone
+            if (tto.offset != 0) {
+                current.start.mseconds -= tto.offset;
+                current.end.mseconds -= tto.offset;
+            }
+            //text is added
+            String[] lines = cleanTextForVTT(current);
+            int i = 0;
+            while (i < lines.length)
+                file.add(index++, "" + lines[i++]);
+            //we add the next blank line
+            file.add(index++, "");
+        }
+
+        String[] toReturn = new String[file.size()];
+        for (int i = 0; i < toReturn.length; i++) {
+            toReturn[i] = file.get(i);
+        }
+        return toReturn;
+    }
+
+
+    /* PRIVATE METHODS */
+
+    /**
+     * This method cleans caption.content of XML and parses line breaks.
+     */
+    private String[] cleanTextForVTT(Caption current) {
+        String[] lines;
+        String text = current.content;
+        //add line breaks
+        lines = text.split("\n");
+        //clean XML
+        for (int i = 0; i < lines.length; i++) {
+            //this will destroy all remaining XML tags
+            lines[i] = lines[i].replaceAll("\\<.*?\\>", "");
+        }
+        return lines;
+    }
+}

package/rules/.source/sdk/support/subtitle-converter/src/main/java/com/quicktvui/support/subtitle/converter/subtitleFile/Region.java

@@ -0,0 +1,5 @@
+package com.quicktvui.support.subtitle.converter.subtitleFile;
+
+public class Region {
+
+}

package/rules/.source/sdk/support/subtitle-converter/src/main/java/com/quicktvui/support/subtitle/converter/subtitleFile/Style.java

@@ -0,0 +1,161 @@
+package com.quicktvui.support.subtitle.converter.subtitleFile;
+
+import android.text.TextUtils;
+
+public class Style {
+	
+	private static int styleCounter;
+
+	/**
+	 * Constructor that receives a String to use a its identifier
+	 * 
+	 * @param styleName = identifier of this style
+	 */
+	protected Style(String styleName) {
+		this.iD = styleName;
+	}
+	
+	/**
+	 * Constructor that receives a String with the new styleName and a style to copy
+	 * 
+	 * @param styleName
+	 * @param style
+	 */
+	protected Style(String styleName, Style style) {
+		this.iD = styleName;
+		this.font = style.font;
+		this.fontSize = style.fontSize;
+		this.color = style.color;
+		this.backgroundColor = style.backgroundColor;
+		this.textAlign = style.textAlign;
+		this.italic = style.italic;
+		this.underline = style.underline;
+		this.bold = style.bold;
+		
+	}
+
+	/* ATTRIBUTES */
+	protected String iD;
+	protected String font;
+	protected String fontSize;
+	/**colors are stored as 8 chars long RGBA*/
+	protected String color;
+	protected String backgroundColor;
+	protected String textAlign = "";
+	
+	protected boolean italic;
+	protected boolean bold;
+	protected boolean underline;
+	
+	/* METHODS */
+	
+	/**
+	 * To get the string containing the hex value to put into color or background color
+	 * 
+	 * @param format supported: "name", "&HBBGGRR", "&HAABBGGRR", "decimalCodedBBGGRR", "decimalCodedAABBGGRR"
+	 * @param value RRGGBBAA string
+	 * @return
+	 */
+	protected static String getRGBValue(String format, String value){
+		String color = null;
+		if (format.equalsIgnoreCase("name")){
+			//standard color format from W3C
+			if (value.equals("transparent"))
+				color = "00000000";
+			else if (value.equals("black"))
+				color = "000000ff";
+			else if (value.equals("silver"))
+				color = "c0c0c0ff";
+			else if (value.equals("gray"))
+				color = "808080ff";
+			else if (value.equals("white"))
+				color = "ffffffff";
+			else if (value.equals("maroon"))
+				color = "800000ff";
+			else if (value.equals("red"))
+				color = "ff0000ff";
+			else if (value.equals("purple"))
+				color = "800080ff";
+			else if (value.equals("fuchsia"))
+				color = "ff00ffff";
+			else if (value.equals("magenta"))
+				color = "ff00ffff ";
+			else if (value.equals("green"))
+				color = "008000ff";
+			else if (value.equals("lime"))
+				color = "00ff00ff";
+			else if (value.equals("olive"))
+				color = "808000ff";
+			else if (value.equals("yellow"))
+				color = "ffff00ff";
+			else if (value.equals("navy"))
+				color = "000080ff";
+			else if (value.equals("blue"))
+				color = "0000ffff";
+			else if (value.equals("teal"))
+				color = "008080ff";
+			else if (value.equals("aqua"))
+				color = "00ffffff";
+			else if (value.equals("cyan"))
+				color = "00ffffff ";
+		} else if (format.equalsIgnoreCase("&HBBGGRR")) {
+			//hex format from SSA
+			if (!TextUtils.isEmpty(value) && value.length() >= 6) {
+				StringBuilder sb = new StringBuilder();
+				sb.append(value.substring(6));
+				sb.append(value.substring(4, 5));
+				sb.append(value.substring(2, 3));
+				sb.append("ff");
+				color = sb.toString();
+			} else {
+				color = "fff";
+			}
+		} else if (format.equalsIgnoreCase("&HAABBGGRR")) {
+			//hex format from ASS
+			if (!TextUtils.isEmpty(value) && value.length() >= 8) {
+				StringBuilder sb = new StringBuilder();
+				sb.append(value.substring(8));
+				sb.append(value.substring(6, 7));
+				sb.append(value.substring(4, 5));
+				sb.append(value.substring(2, 3));
+				color = sb.toString();
+			} else {
+				color = "fff";
+			}
+		} else if (format.equalsIgnoreCase("decimalCodedBBGGRR")){
+			//normal format from SSA
+			color = Integer.toHexString(Integer.parseInt(value));
+			//any missing 0s are filled in
+			while(color.length()<6)color="0"+color;
+			//order is reversed
+			color = color.substring(4)+color.substring(2,4)+color.substring(0,2)+"ff";
+		}  else if (format.equalsIgnoreCase("decimalCodedAABBGGRR")){
+			//normal format from ASS
+			color = Long.toHexString(Long.parseLong(value));
+			//any missing 0s are filled in
+			while(color.length()<8)color="0"+color;
+			//order is reversed
+			color = color.substring(6)+color.substring(4,6)+color.substring(2,4)+color.substring(0,2);
+		}
+		 return color;
+	}
+
+	protected static String defaultID() {
+		return "default"+styleCounter++;
+	}
+
+    @Override
+    public String toString() {
+        return "Style{" +
+                "id='" + iD + '\'' +
+                ", font='" + font + '\'' +
+                ", fontSize='" + fontSize + '\'' +
+                ", color='" + color + '\'' +
+                ", backgroundColor='" + backgroundColor + '\'' +
+                ", textAlign='" + textAlign + '\'' +
+                ", italic=" + italic +
+                ", bold=" + bold +
+                ", underline=" + underline +
+                '}';
+    }
+}

package/rules/.source/sdk/support/subtitle-converter/src/main/java/com/quicktvui/support/subtitle/converter/subtitleFile/SubtitleResult.java

@@ -0,0 +1,16 @@
+package com.quicktvui.support.subtitle.converter.subtitleFile;
+
+import java.io.Serializable;
+import java.util.HashMap;
+
+public class SubtitleResult implements Serializable {
+    private HashMap<String, TimedTextObject> timedTextMap;
+
+    public HashMap<String, TimedTextObject> getTimedTextMap() {
+        return timedTextMap;
+    }
+
+    public void setTimedTextMap(HashMap<String, TimedTextObject> timedTextMap) {
+        this.timedTextMap = timedTextMap;
+    }
+}

package/rules/.source/sdk/support/subtitle-converter/src/main/java/com/quicktvui/support/subtitle/converter/subtitleFile/SubtitleText.java

@@ -0,0 +1,42 @@
+package com.quicktvui.support.subtitle.converter.subtitleFile;
+
+import java.io.Serializable;
+
+public class SubtitleText implements Serializable {
+    private String tag; //文件名+“_SRT”等
+    private String fileName; //文件名
+    private String mimeType; //SRT ASS STL TTML/XML
+    private TimedTextObject tto;
+
+    public String getMimeType() {
+        return mimeType;
+    }
+
+    public void setMimeType(String mimeType) {
+        this.mimeType = mimeType;
+    }
+
+    public String getFileName() {
+        return fileName;
+    }
+
+    public void setFileName(String fileName) {
+        this.fileName = fileName;
+    }
+
+    public String getTag() {
+        return tag;
+    }
+
+    public void setTag(String tag) {
+        this.tag = tag;
+    }
+
+    public TimedTextObject getTto() {
+        return tto;
+    }
+
+    public void setTto(TimedTextObject tto) {
+        this.tto = tto;
+    }
+}

package/rules/.source/sdk/support/subtitle-converter/src/main/java/com/quicktvui/support/subtitle/converter/subtitleFile/Time.java

@@ -0,0 +1,209 @@
+package com.quicktvui.support.subtitle.converter.subtitleFile;
+
+public class Time {
+	
+	/**
+	 * Constructor to create a time object.
+	 * 
+	 * @param format supported formats: "hh:mm:ss,ms", "h:mm:ss.cs" and "h:m:s:f/fps"
+	 * @param value  string in the correct format
+	 */
+	protected Time(String format, String value) {
+		if (format.equalsIgnoreCase("hh:mm:ss,ms")){
+			// this type of format:  01:02:22,501 (used in .SRT)
+			int h, m, s, ms;
+			h = Integer.parseInt(value.substring(0, 2));
+			m = Integer.parseInt(value.substring(3, 5));
+			s = Integer.parseInt(value.substring(6, 8));
+			ms = Integer.parseInt(value.substring(9, 12));
+			
+			mseconds = ms + s*1000 + m*60000 + h*3600000;
+			
+		} else if (format.equalsIgnoreCase("h:mm:ss.cs")){
+			// this type of format:  1:02:22.51 (used in .ASS/.SSA) 
+			int h, m, s, cs;
+			String[] hms = value.split(":");
+			h = Integer.parseInt(hms[0]);
+			m = Integer.parseInt(hms[1]);
+			s = Integer.parseInt(hms[2].split("\\.")[0]);
+			cs = Integer.parseInt(hms[2].split("\\.")[1]);
+//			s = Integer.parseInt(hms[2].substring(0, 2));
+//			cs = Integer.parseInt(hms[2].substring(3, 5));
+
+			mseconds = cs*10 + s*1000 + m*60000 + h*3600000;
+		} else if (format.equalsIgnoreCase("h:m:s:f/fps")){
+			int h, m, s, f;
+			float fps;
+			String[] args = value.split("/");
+			fps = Float.parseFloat(args[1]);
+			args = args[0].split(":");
+			h = Integer.parseInt(args[0]);
+			m = Integer.parseInt(args[1]);
+			s = Integer.parseInt(args[2]);
+			f = Integer.parseInt(args[3]);
+
+			mseconds = (int)(f*1000/fps) + s*1000 + m*60000 + h*3600000;
+		}
+	}
+
+	// in an integer we can store 24 days worth of milliseconds, no need for a long
+	protected int mseconds;
+
+    public int getMseconds() {
+        return mseconds;
+    }
+
+    public void setMseconds(int mseconds) {
+        this.mseconds = mseconds;
+    }
+
+    /* METHODS */
+	
+	/**
+	 * Method to return a formatted value of the time stored
+	 * 
+	 * @param format supported formats: "hh:mm:ss,ms", "h:mm:ss.cs" and "hhmmssff/fps"
+	 * @return formatted time in a string
+	 */
+	protected String getTime(String format) {
+		//we use string builder for efficiency
+		StringBuilder time = new StringBuilder();
+		String aux;
+		if(format.equalsIgnoreCase("hh:mm:ss,ms")){
+			// this type of format:  01:02:22,501 (used in .SRT)
+			int h, m, s, ms;
+			h =  mseconds/3600000;
+			aux = String.valueOf(h);
+			if (aux.length()==1) time.append('0');
+			time.append(aux);
+			time.append(':');
+			m = (mseconds/60000)%60;
+			aux = String.valueOf(m);
+			if (aux.length()==1) time.append('0');
+			time.append(aux);
+			time.append(':');
+			s = (mseconds/1000)%60;
+			aux = String.valueOf(s);
+			if (aux.length()==1) time.append('0');
+			time.append(aux);
+			time.append(',');
+			ms = mseconds%1000;
+			aux = String.valueOf(ms);
+			if (aux.length()==1) time.append("00");
+			else if (aux.length()==2) time.append('0');
+			time.append(aux);
+			
+		} else if(format.equalsIgnoreCase("h:mm:ss.cs")){
+			// this type of format:  1:02:22.51 (used in .ASS/.SSA)
+			int h, m, s, cs;
+			h =  mseconds/3600000;
+			aux = String.valueOf(h);
+			if (aux.length()==1) time.append('0');
+			time.append(aux);
+			time.append(':');
+			m = (mseconds/60000)%60;
+			aux = String.valueOf(m);
+			if (aux.length()==1) time.append('0');
+			time.append(aux);
+			time.append(':');
+			s = (mseconds/1000)%60;
+			aux = String.valueOf(s);
+			if (aux.length()==1) time.append('0');
+			time.append(aux);
+			time.append('.');
+			cs = (mseconds/10)%100;
+			aux = String.valueOf(cs);
+			if (aux.length()==1) time.append('0');
+			time.append(aux);
+			
+		} else if (format.startsWith("hhmmssff/")){
+			//this format is used in EBU's STL
+			int h, m, s, f;
+			float fps;
+			String[] args = format.split("/");
+			fps = Float.parseFloat(args[1]);
+			//now we concatenate time
+			h =  mseconds/3600000;
+			aux = String.valueOf(h);
+			if (aux.length()==1) time.append('0');
+			time.append(aux);
+			m = (mseconds/60000)%60;
+			aux = String.valueOf(m);
+			if (aux.length()==1) time.append('0');
+			time.append(aux);
+			s = (mseconds/1000)%60;
+			aux = String.valueOf(s);
+			if (aux.length()==1) time.append('0');
+			time.append(aux);
+			f = (mseconds%1000)*(int)fps/1000;
+			aux = String.valueOf(f);
+			if (aux.length()==1) time.append('0');
+			time.append(aux);
+			
+		} else if (format.startsWith("h:m:s:f/")){
+			//this format is used in EBU's STL
+			int h, m, s, f;
+			float fps;
+			String[] args = format.split("/");
+			fps = Float.parseFloat(args[1]);
+			//now we concatenate time
+			h =  mseconds/3600000;
+			aux = String.valueOf(h);
+			//if (aux.length()==1) time.append('0');
+			time.append(aux);
+			time.append(':');
+			m = (mseconds/60000)%60;
+			aux = String.valueOf(m);
+			//if (aux.length()==1) time.append('0');
+			time.append(aux);
+			time.append(':');
+			s = (mseconds/1000)%60;
+			aux = String.valueOf(s);
+			//if (aux.length()==1) time.append('0');
+			time.append(aux);
+			time.append(':');
+			f = (mseconds%1000)*(int)fps/1000;
+			aux = String.valueOf(f);
+			//if (aux.length()==1) time.append('0');
+			time.append(aux);
+		} else if (format.startsWith("hh:mm:ss:ff/")){
+			//this format is used in SCC
+			int h, m, s, f;
+			float fps;
+			String[] args = format.split("/");
+			fps = Float.parseFloat(args[1]);
+			//now we concatenate time
+			h =  mseconds/3600000;
+			aux = String.valueOf(h);
+			if (aux.length()==1) time.append('0');
+			time.append(aux);
+			time.append(':');
+			m = (mseconds/60000)%60;
+			aux = String.valueOf(m);
+			if (aux.length()==1) time.append('0');
+			time.append(aux);
+			time.append(':');
+			s = (mseconds/1000)%60;
+			aux = String.valueOf(s);
+			if (aux.length()==1) time.append('0');
+			time.append(aux);
+			time.append(':');
+			f = (mseconds%1000)*(int)fps/1000;
+			aux = String.valueOf(f);
+			if (aux.length()==1) time.append('0');
+			time.append(aux);
+		}
+
+		return time.toString();
+	}
+
+    /**
+     * ASS/SSA time format.
+     * @return ASS/SSA time format.
+     */
+    @Override
+    public String toString() {
+        return getTime("h:mm:ss.cs");
+    }
+
+}