| /* |
| * 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 com.android.tv.tuner.ts; |
| |
| import android.media.tv.TvContentRating; |
| import android.media.tv.TvContract.Programs.Genres; |
| import android.support.annotation.VisibleForTesting; |
| import android.text.TextUtils; |
| import android.util.ArraySet; |
| import android.util.Log; |
| import android.util.SparseArray; |
| |
| import com.android.tv.tuner.data.PsiData.PatItem; |
| import com.android.tv.tuner.data.PsiData.PmtItem; |
| import com.android.tv.tuner.data.PsipData.Ac3AudioDescriptor; |
| import com.android.tv.tuner.data.PsipData.CaptionServiceDescriptor; |
| import com.android.tv.tuner.data.PsipData.ContentAdvisoryDescriptor; |
| import com.android.tv.tuner.data.PsipData.EitItem; |
| import com.android.tv.tuner.data.PsipData.EttItem; |
| import com.android.tv.tuner.data.PsipData.ExtendedChannelNameDescriptor; |
| import com.android.tv.tuner.data.PsipData.GenreDescriptor; |
| import com.android.tv.tuner.data.PsipData.Iso639LanguageDescriptor; |
| import com.android.tv.tuner.data.PsipData.MgtItem; |
| import com.android.tv.tuner.data.PsipData.ParentalRatingDescriptor; |
| import com.android.tv.tuner.data.PsipData.PsipSection; |
| import com.android.tv.tuner.data.PsipData.RatingRegion; |
| import com.android.tv.tuner.data.PsipData.RegionalRating; |
| import com.android.tv.tuner.data.PsipData.SdtItem; |
| import com.android.tv.tuner.data.PsipData.ServiceDescriptor; |
| import com.android.tv.tuner.data.PsipData.ShortEventDescriptor; |
| import com.android.tv.tuner.data.PsipData.TsDescriptor; |
| import com.android.tv.tuner.data.PsipData.VctItem; |
| import com.android.tv.tuner.data.nano.Channel; |
| import com.android.tv.tuner.data.nano.Track.AtscAudioTrack; |
| import com.android.tv.tuner.data.nano.Track.AtscCaptionTrack; |
| import com.android.tv.tuner.util.ByteArrayBuffer; |
| |
| import com.android.tv.tuner.util.ConvertUtils; |
| import com.ibm.icu.text.UnicodeDecompressor; |
| |
| import java.io.UnsupportedEncodingException; |
| import java.nio.charset.Charset; |
| import java.util.Calendar; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| /** |
| * Parses ATSC PSIP sections. |
| */ |
| public class SectionParser { |
| private static final String TAG = "SectionParser"; |
| private static final boolean DEBUG = false; |
| |
| private static final byte TABLE_ID_PAT = (byte) 0x00; |
| private static final byte TABLE_ID_PMT = (byte) 0x02; |
| private static final byte TABLE_ID_MGT = (byte) 0xc7; |
| private static final byte TABLE_ID_TVCT = (byte) 0xc8; |
| private static final byte TABLE_ID_CVCT = (byte) 0xc9; |
| private static final byte TABLE_ID_EIT = (byte) 0xcb; |
| private static final byte TABLE_ID_ETT = (byte) 0xcc; |
| |
| // Table id for DVB |
| private static final byte TABLE_ID_SDT = (byte) 0x42; |
| private static final byte TABLE_ID_DVB_ACTUAL_P_F_EIT = (byte) 0x4e; |
| private static final byte TABLE_ID_DVB_OTHER_P_F_EIT = (byte) 0x4f; |
| private static final byte TABLE_ID_DVB_ACTUAL_SCHEDULE_EIT = (byte) 0x50; |
| private static final byte TABLE_ID_DVB_OTHER_SCHEDULE_EIT = (byte) 0x60; |
| |
| // For details of the structure for the tags of descriptors, see ATSC A/65 Table 6.25. |
| public static final int DESCRIPTOR_TAG_ISO639LANGUAGE = 0x0a; |
| public static final int DESCRIPTOR_TAG_CAPTION_SERVICE = 0x86; |
| public static final int DESCRIPTOR_TAG_CONTENT_ADVISORY = 0x87; |
| public static final int DESCRIPTOR_TAG_AC3_AUDIO_STREAM = 0x81; |
| public static final int DESCRIPTOR_TAG_EXTENDED_CHANNEL_NAME = 0xa0; |
| public static final int DESCRIPTOR_TAG_GENRE = 0xab; |
| |
| // For details of the structure for the tags of DVB descriptors, see DVB Document A038 Table 12. |
| public static final int DVB_DESCRIPTOR_TAG_SERVICE = 0x48; |
| public static final int DVB_DESCRIPTOR_TAG_SHORT_EVENT = 0X4d; |
| public static final int DVB_DESCRIPTOR_TAG_CONTENT = 0x54; |
| public static final int DVB_DESCRIPTOR_TAG_PARENTAL_RATING = 0x55; |
| |
| private static final byte COMPRESSION_TYPE_NO_COMPRESSION = (byte) 0x00; |
| private static final byte MODE_SELECTED_UNICODE_RANGE_1 = (byte) 0x00; // 0x0000 - 0x00ff |
| private static final byte MODE_UTF16 = (byte) 0x3f; |
| private static final byte MODE_SCSU = (byte) 0x3e; |
| private static final int MAX_SHORT_NAME_BYTES = 14; |
| |
| // See ANSI/CEA-766-C. |
| private static final int RATING_REGION_US_TV = 1; |
| private static final int RATING_REGION_KR_TV = 4; |
| |
| // The following values are defined in the live channels app. |
| // See https://developer.android.com/reference/android/media/tv/TvContentRating.html. |
| private static final String RATING_DOMAIN = "com.android.tv"; |
| private static final String RATING_REGION_RATING_SYSTEM_US_TV = "US_TV"; |
| private static final String RATING_REGION_RATING_SYSTEM_US_MV = "US_MV"; |
| private static final String RATING_REGION_RATING_SYSTEM_KR_TV = "KR_TV"; |
| |
| private static final String[] RATING_REGION_TABLE_US_TV = { |
| "US_TV_Y", "US_TV_Y7", "US_TV_G", "US_TV_PG", "US_TV_14", "US_TV_MA" |
| }; |
| |
| private static final String[] RATING_REGION_TABLE_US_MV = { |
| "US_MV_G", "US_MV_PG", "US_MV_PG13", "US_MV_R", "US_MV_NC17" |
| }; |
| |
| private static final String[] RATING_REGION_TABLE_KR_TV = { |
| "KR_TV_ALL", "KR_TV_7", "KR_TV_12", "KR_TV_15", "KR_TV_19" |
| }; |
| |
| private static final String[] RATING_REGION_TABLE_US_TV_SUBRATING = { |
| "US_TV_D", "US_TV_L", "US_TV_S", "US_TV_V", "US_TV_FV" |
| }; |
| |
| // According to ANSI-CEA-766-D |
| private static final int VALUE_US_TV_Y = 1; |
| private static final int VALUE_US_TV_Y7 = 2; |
| private static final int VALUE_US_TV_NONE = 1; |
| private static final int VALUE_US_TV_G = 2; |
| private static final int VALUE_US_TV_PG = 3; |
| private static final int VALUE_US_TV_14 = 4; |
| private static final int VALUE_US_TV_MA = 5; |
| |
| private static final int DIMENSION_US_TV_RATING = 0; |
| private static final int DIMENSION_US_TV_D = 1; |
| private static final int DIMENSION_US_TV_L = 2; |
| private static final int DIMENSION_US_TV_S = 3; |
| private static final int DIMENSION_US_TV_V = 4; |
| private static final int DIMENSION_US_TV_Y = 5; |
| private static final int DIMENSION_US_TV_FV = 6; |
| private static final int DIMENSION_US_MV_RATING = 7; |
| |
| private static final int VALUE_US_MV_G = 2; |
| private static final int VALUE_US_MV_PG = 3; |
| private static final int VALUE_US_MV_PG13 = 4; |
| private static final int VALUE_US_MV_R = 5; |
| private static final int VALUE_US_MV_NC17 = 6; |
| private static final int VALUE_US_MV_X = 7; |
| |
| private static final String STRING_US_TV_Y = "US_TV_Y"; |
| private static final String STRING_US_TV_Y7 = "US_TV_Y7"; |
| private static final String STRING_US_TV_FV = "US_TV_FV"; |
| |
| |
| /* |
| * The following CRC table is from the code generated by the following command. |
| * $ python pycrc.py --model crc-32-mpeg --algorithm table-driven --generate c |
| * To see the details of pycrc, visit http://www.tty1.net/pycrc/index_en.html |
| */ |
| public static final int[] CRC_TABLE = { |
| 0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, |
| 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005, |
| 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, |
| 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, |
| 0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, |
| 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75, |
| 0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, |
| 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd, |
| 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, |
| 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, |
| 0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, |
| 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d, |
| 0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, |
| 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95, |
| 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, |
| 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, |
| 0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, |
| 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072, |
| 0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, |
| 0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca, |
| 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, |
| 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, |
| 0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, |
| 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba, |
| 0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, |
| 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692, |
| 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, |
| 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, |
| 0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, |
| 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2, |
| 0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, |
| 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a, |
| 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, |
| 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, |
| 0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, |
| 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53, |
| 0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, |
| 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b, |
| 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff, |
| 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, |
| 0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, |
| 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b, |
| 0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, |
| 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3, |
| 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, |
| 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, |
| 0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, |
| 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3, |
| 0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, |
| 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, |
| 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, |
| 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, |
| 0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, |
| 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec, |
| 0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, |
| 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654, |
| 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, |
| 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, |
| 0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, |
| 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, |
| 0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, |
| 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c, |
| 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, |
| 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4 |
| }; |
| |
| // A table which maps ATSC genres to TIF genres. |
| // See ATSC/65 Table 6.20. |
| private static final String[] CANONICAL_GENRES_TABLE = { |
| null, null, null, null, |
| null, null, null, null, |
| null, null, null, null, |
| null, null, null, null, |
| null, null, null, null, |
| null, null, null, null, |
| null, null, null, null, |
| null, null, null, null, |
| Genres.EDUCATION, Genres.ENTERTAINMENT, Genres.MOVIES, Genres.NEWS, |
| Genres.LIFE_STYLE, Genres.SPORTS, null, Genres.MOVIES, |
| null, |
| Genres.FAMILY_KIDS, Genres.DRAMA, null, Genres.ENTERTAINMENT, Genres.SPORTS, |
| Genres.SPORTS, |
| null, null, |
| Genres.MUSIC, Genres.EDUCATION, |
| null, |
| Genres.COMEDY, |
| null, |
| Genres.MUSIC, |
| null, null, |
| Genres.MOVIES, Genres.ENTERTAINMENT, Genres.NEWS, Genres.DRAMA, |
| Genres.EDUCATION, Genres.MOVIES, Genres.SPORTS, Genres.MOVIES, |
| null, |
| Genres.LIFE_STYLE, Genres.ARTS, Genres.LIFE_STYLE, Genres.SPORTS, |
| null, null, |
| Genres.GAMING, Genres.LIFE_STYLE, Genres.SPORTS, |
| null, |
| Genres.LIFE_STYLE, Genres.EDUCATION, Genres.EDUCATION, Genres.LIFE_STYLE, |
| Genres.SPORTS, Genres.LIFE_STYLE, Genres.MOVIES, Genres.NEWS, |
| null, null, null, |
| Genres.EDUCATION, |
| null, null, null, |
| Genres.EDUCATION, |
| null, null, null, |
| Genres.DRAMA, Genres.MUSIC, Genres.MOVIES, |
| null, |
| Genres.ANIMAL_WILDLIFE, |
| null, null, |
| Genres.PREMIER, |
| null, null, null, null, |
| Genres.SPORTS, Genres.ARTS, |
| null, null, null, |
| Genres.MOVIES, Genres.TECH_SCIENCE, Genres.DRAMA, |
| null, |
| Genres.SHOPPING, Genres.DRAMA, |
| null, |
| Genres.MOVIES, Genres.ENTERTAINMENT, Genres.TECH_SCIENCE, Genres.SPORTS, |
| Genres.TRAVEL, Genres.ENTERTAINMENT, Genres.ARTS, Genres.NEWS, |
| null, |
| Genres.ARTS, Genres.SPORTS, Genres.SPORTS, Genres.NEWS, |
| Genres.SPORTS, Genres.SPORTS, Genres.SPORTS, Genres.FAMILY_KIDS, |
| Genres.FAMILY_KIDS, Genres.MOVIES, |
| null, |
| Genres.TECH_SCIENCE, Genres.MUSIC, |
| null, |
| Genres.SPORTS, Genres.FAMILY_KIDS, Genres.NEWS, Genres.SPORTS, |
| Genres.NEWS, Genres.SPORTS, Genres.ANIMAL_WILDLIFE, |
| null, |
| Genres.MUSIC, Genres.NEWS, Genres.SPORTS, |
| null, |
| Genres.NEWS, Genres.NEWS, Genres.NEWS, Genres.NEWS, |
| Genres.SPORTS, Genres.MOVIES, Genres.ARTS, Genres.ANIMAL_WILDLIFE, |
| Genres.MUSIC, Genres.MUSIC, Genres.MOVIES, Genres.EDUCATION, |
| Genres.DRAMA, Genres.SPORTS, Genres.SPORTS, Genres.SPORTS, |
| Genres.SPORTS, |
| null, |
| Genres.SPORTS, Genres.SPORTS, |
| }; |
| |
| // A table which contains ATSC categorical genre code assignments. |
| // See ATSC/65 Table 6.20. |
| private static final String[] BROADCAST_GENRES_TABLE = new String[] { |
| null, null, null, null, |
| null, null, null, null, |
| null, null, null, null, |
| null, null, null, null, |
| null, null, null, null, |
| null, null, null, null, |
| null, null, null, null, |
| null, null, null, null, |
| "Education", "Entertainment", "Movie", "News", |
| "Religious", "Sports", "Other", "Action", |
| "Advertisement", "Animated", "Anthology", "Automobile", |
| "Awards", "Baseball", "Basketball", "Bulletin", |
| "Business", "Classical", "College", "Combat", |
| "Comedy", "Commentary", "Concert", "Consumer", |
| "Contemporary", "Crime", "Dance", "Documentary", |
| "Drama", "Elementary", "Erotica", "Exercise", |
| "Fantasy", "Farm", "Fashion", "Fiction", |
| "Food", "Football", "Foreign", "Fund Raiser", |
| "Game/Quiz", "Garden", "Golf", "Government", |
| "Health", "High School", "History", "Hobby", |
| "Hockey", "Home", "Horror", "Information", |
| "Instruction", "International", "Interview", "Language", |
| "Legal", "Live", "Local", "Math", |
| "Medical", "Meeting", "Military", "Miniseries", |
| "Music", "Mystery", "National", "Nature", |
| "Police", "Politics", "Premier", "Prerecorded", |
| "Product", "Professional", "Public", "Racing", |
| "Reading", "Repair", "Repeat", "Review", |
| "Romance", "Science", "Series", "Service", |
| "Shopping", "Soap Opera", "Special", "Suspense", |
| "Talk", "Technical", "Tennis", "Travel", |
| "Variety", "Video", "Weather", "Western", |
| "Art", "Auto Racing", "Aviation", "Biography", |
| "Boating", "Bowling", "Boxing", "Cartoon", |
| "Children", "Classic Film", "Community", "Computers", |
| "Country Music", "Court", "Extreme Sports", "Family", |
| "Financial", "Gymnastics", "Headlines", "Horse Racing", |
| "Hunting/Fishing/Outdoors", "Independent", "Jazz", "Magazine", |
| "Motorcycle Racing", "Music/Film/Books", "News-International", "News-Local", |
| "News-National", "News-Regional", "Olympics", "Original", |
| "Performing Arts", "Pets/Animals", "Pop", "Rock & Roll", |
| "Sci-Fi", "Self Improvement", "Sitcom", "Skating", |
| "Skiing", "Soccer", "Track/Field", "True", |
| "Volleyball", "Wrestling", |
| }; |
| |
| // Audio language code map from ISO 639-2/B to 639-2/T, in order to show correct audio language. |
| private static final HashMap<String, String> ISO_LANGUAGE_CODE_MAP; |
| static { |
| ISO_LANGUAGE_CODE_MAP = new HashMap<>(); |
| ISO_LANGUAGE_CODE_MAP.put("alb", "sqi"); |
| ISO_LANGUAGE_CODE_MAP.put("arm", "hye"); |
| ISO_LANGUAGE_CODE_MAP.put("baq", "eus"); |
| ISO_LANGUAGE_CODE_MAP.put("bur", "mya"); |
| ISO_LANGUAGE_CODE_MAP.put("chi", "zho"); |
| ISO_LANGUAGE_CODE_MAP.put("cze", "ces"); |
| ISO_LANGUAGE_CODE_MAP.put("dut", "nld"); |
| ISO_LANGUAGE_CODE_MAP.put("fre", "fra"); |
| ISO_LANGUAGE_CODE_MAP.put("geo", "kat"); |
| ISO_LANGUAGE_CODE_MAP.put("ger", "deu"); |
| ISO_LANGUAGE_CODE_MAP.put("gre", "ell"); |
| ISO_LANGUAGE_CODE_MAP.put("ice", "isl"); |
| ISO_LANGUAGE_CODE_MAP.put("mac", "mkd"); |
| ISO_LANGUAGE_CODE_MAP.put("mao", "mri"); |
| ISO_LANGUAGE_CODE_MAP.put("may", "msa"); |
| ISO_LANGUAGE_CODE_MAP.put("per", "fas"); |
| ISO_LANGUAGE_CODE_MAP.put("rum", "ron"); |
| ISO_LANGUAGE_CODE_MAP.put("slo", "slk"); |
| ISO_LANGUAGE_CODE_MAP.put("tib", "bod"); |
| ISO_LANGUAGE_CODE_MAP.put("wel", "cym"); |
| ISO_LANGUAGE_CODE_MAP.put("esl", "spa"); // Special entry for channel 9-1 KQED in bay area. |
| } |
| |
| // Containers to store the last version numbers of the PSIP sections. |
| private final HashMap<PsipSection, Integer> mSectionVersionMap = new HashMap<>(); |
| private final SparseArray<List<EttItem>> mParsedEttItems = new SparseArray<>(); |
| |
| public interface OutputListener { |
| void onPatParsed(List<PatItem> items); |
| void onPmtParsed(int programNumber, List<PmtItem> items); |
| void onMgtParsed(List<MgtItem> items); |
| void onVctParsed(List<VctItem> items, int sectionNumber, int lastSectionNumber); |
| void onEitParsed(int sourceId, List<EitItem> items); |
| void onEttParsed(int sourceId, List<EttItem> descriptions); |
| void onSdtParsed(List<SdtItem> items); |
| } |
| |
| private final OutputListener mListener; |
| |
| public SectionParser(OutputListener listener) { |
| mListener = listener; |
| } |
| |
| public void parseSections(ByteArrayBuffer data) { |
| int pos = 0; |
| while (pos + 3 <= data.length()) { |
| if ((data.byteAt(pos) & 0xff) == 0xff) { |
| // Clear stuffing bytes according to H222.0 section 2.4.4. |
| data.setLength(0); |
| break; |
| } |
| int sectionLength = |
| (((data.byteAt(pos + 1) & 0x0f) << 8) | (data.byteAt(pos + 2) & 0xff)) + 3; |
| if (pos + sectionLength > data.length()) { |
| break; |
| } |
| if (DEBUG) { |
| Log.d(TAG, "parseSections 0x" + Integer.toHexString(data.byteAt(pos) & 0xff)); |
| } |
| parseSection(Arrays.copyOfRange(data.buffer(), pos, pos + sectionLength)); |
| pos += sectionLength; |
| } |
| if (mListener != null) { |
| for (int i = 0; i < mParsedEttItems.size(); ++i) { |
| int sourceId = mParsedEttItems.keyAt(i); |
| List<EttItem> descriptions = mParsedEttItems.valueAt(i); |
| mListener.onEttParsed(sourceId, descriptions); |
| } |
| } |
| mParsedEttItems.clear(); |
| } |
| |
| public void resetVersionNumbers() { |
| mSectionVersionMap.clear(); |
| } |
| |
| private void parseSection(byte[] data) { |
| if (!checkSanity(data)) { |
| Log.d(TAG, "Bad CRC!"); |
| return; |
| } |
| PsipSection section = PsipSection.create(data); |
| if (section == null) { |
| return; |
| } |
| |
| // The currentNextIndicator indicates that the section sent is currently applicable. |
| if (!section.getCurrentNextIndicator()) { |
| return; |
| } |
| int versionNumber = (data[5] & 0x3e) >> 1; |
| Integer oldVersionNumber = mSectionVersionMap.get(section); |
| |
| // The versionNumber shall be incremented when a change in the information carried within |
| // the section occurs. |
| if (oldVersionNumber != null && versionNumber == oldVersionNumber) { |
| return; |
| } |
| boolean result = false; |
| switch (data[0]) { |
| case TABLE_ID_PAT: |
| result = parsePAT(data); |
| break; |
| case TABLE_ID_PMT: |
| result = parsePMT(data); |
| break; |
| case TABLE_ID_MGT: |
| result = parseMGT(data); |
| break; |
| case TABLE_ID_TVCT: |
| case TABLE_ID_CVCT: |
| result = parseVCT(data); |
| break; |
| case TABLE_ID_EIT: |
| result = parseEIT(data); |
| break; |
| case TABLE_ID_ETT: |
| result = parseETT(data); |
| break; |
| case TABLE_ID_SDT: |
| result = parseSDT(data); |
| break; |
| case TABLE_ID_DVB_ACTUAL_P_F_EIT: |
| case TABLE_ID_DVB_ACTUAL_SCHEDULE_EIT: |
| result = parseDVBEIT(data); |
| break; |
| default: |
| break; |
| } |
| if (result) { |
| mSectionVersionMap.put(section, versionNumber); |
| } |
| } |
| |
| private boolean parsePAT(byte[] data) { |
| if (DEBUG) { |
| Log.d(TAG, "PAT is discovered."); |
| } |
| int pos = 8; |
| |
| List<PatItem> results = new ArrayList<>(); |
| for (; pos < data.length - 4; pos = pos + 4) { |
| if (pos > data.length - 4 - 4) { |
| Log.e(TAG, "Broken PAT."); |
| return false; |
| } |
| int programNo = ((data[pos] & 0xff) << 8) | (data[pos + 1] & 0xff); |
| int pmtPid = ((data[pos + 2] & 0x1f) << 8) | (data[pos + 3] & 0xff); |
| results.add(new PatItem(programNo, pmtPid)); |
| } |
| if (mListener != null) { |
| mListener.onPatParsed(results); |
| } |
| return true; |
| } |
| |
| private boolean parsePMT(byte[] data) { |
| int table_id_ext = ((data[3] & 0xff) << 8) | (data[4] & 0xff); |
| if (DEBUG) { |
| Log.d(TAG, "PMT is discovered. programNo = " + table_id_ext); |
| } |
| if (data.length <= 11) { |
| Log.e(TAG, "Broken PMT."); |
| return false; |
| } |
| int pcrPid = (data[8] & 0x1f) << 8 | data[9]; |
| int programInfoLen = (data[10] & 0x0f) << 8 | data[11]; |
| int pos = 12; |
| List<TsDescriptor> descriptors = parseDescriptors(data, pos, pos + programInfoLen); |
| pos += programInfoLen; |
| if (DEBUG) { |
| Log.d(TAG, "PMT descriptors size: " + descriptors.size()); |
| } |
| List<PmtItem> results = new ArrayList<>(); |
| for (; pos < data.length - 4;) { |
| if (pos < 0) { |
| Log.e(TAG, "Broken PMT."); |
| return false; |
| } |
| int streamType = data[pos] & 0xff; |
| int esPid = (data[pos + 1] & 0x1f) << 8 | (data[pos + 2] & 0xff); |
| int esInfoLen = (data[pos + 3] & 0xf) << 8 | (data[pos + 4] & 0xff); |
| if (data.length < pos + esInfoLen + 5) { |
| Log.e(TAG, "Broken PMT."); |
| return false; |
| } |
| descriptors = parseDescriptors(data, pos + 5, pos + 5 + esInfoLen); |
| List<AtscAudioTrack> audioTracks = generateAudioTracks(descriptors); |
| List<AtscCaptionTrack> captionTracks = generateCaptionTracks(descriptors); |
| PmtItem pmtItem = new PmtItem(streamType, esPid, audioTracks, captionTracks); |
| if (DEBUG) { |
| Log.d(TAG, "PMT " + pmtItem + " descriptors size: " + descriptors.size()); |
| } |
| results.add(pmtItem); |
| pos = pos + esInfoLen + 5; |
| } |
| results.add(new PmtItem(PmtItem.ES_PID_PCR, pcrPid, null, null)); |
| if (mListener != null) { |
| mListener.onPmtParsed(table_id_ext, results); |
| } |
| return true; |
| } |
| |
| private boolean parseMGT(byte[] data) { |
| // For details of the structure for MGT, see ATSC A/65 Table 6.2. |
| if (DEBUG) { |
| Log.d(TAG, "MGT is discovered."); |
| } |
| if (data.length <= 10) { |
| Log.e(TAG, "Broken MGT."); |
| return false; |
| } |
| int tablesDefined = ((data[9] & 0xff) << 8) | (data[10] & 0xff); |
| int pos = 11; |
| List<MgtItem> results = new ArrayList<>(); |
| for (int i = 0; i < tablesDefined; ++i) { |
| if (data.length <= pos + 10) { |
| Log.e(TAG, "Broken MGT."); |
| return false; |
| } |
| int tableType = ((data[pos] & 0xff) << 8) | (data[pos + 1] & 0xff); |
| int tableTypePid = ((data[pos + 2] & 0x1f) << 8) | (data[pos + 3] & 0xff); |
| int descriptorsLength = ((data[pos + 9] & 0x0f) << 8) | (data[pos + 10] & 0xff); |
| pos += 11 + descriptorsLength; |
| results.add(new MgtItem(tableType, tableTypePid)); |
| } |
| // Skip the remaining descriptor part which we don't use. |
| |
| if (mListener != null) { |
| mListener.onMgtParsed(results); |
| } |
| return true; |
| } |
| |
| private boolean parseVCT(byte[] data) { |
| // For details of the structure for VCT, see ATSC A/65 Table 6.4 and 6.8. |
| if (DEBUG) { |
| Log.d(TAG, "VCT is discovered."); |
| } |
| if (data.length <= 9) { |
| Log.e(TAG, "Broken VCT."); |
| return false; |
| } |
| int numChannelsInSection = (data[9] & 0xff); |
| int sectionNumber = (data[6] & 0xff); |
| int lastSectionNumber = (data[7] & 0xff); |
| if (sectionNumber > lastSectionNumber) { |
| // According to section 6.3.1 of the spec ATSC A/65, |
| // last section number is the largest section number. |
| Log.w(TAG, "Invalid VCT. Section Number " + sectionNumber + " > Last Section Number " |
| + lastSectionNumber); |
| return false; |
| } |
| int pos = 10; |
| List<VctItem> results = new ArrayList<>(); |
| for (int i = 0; i < numChannelsInSection; ++i) { |
| if (data.length <= pos + 31) { |
| Log.e(TAG, "Broken VCT."); |
| return false; |
| } |
| String shortName = ""; |
| int shortNameSize = getShortNameSize(data, pos); |
| try { |
| shortName = new String( |
| Arrays.copyOfRange(data, pos, pos + shortNameSize), "UTF-16"); |
| } catch (UnsupportedEncodingException e) { |
| Log.e(TAG, "Broken VCT.", e); |
| return false; |
| } |
| if ((data[pos + 14] & 0xf0) != 0xf0) { |
| Log.e(TAG, "Broken VCT."); |
| return false; |
| } |
| int majorNumber = ((data[pos + 14] & 0x0f) << 6) | ((data[pos + 15] & 0xff) >> 2); |
| int minorNumber = ((data[pos + 15] & 0x03) << 8) | (data[pos + 16] & 0xff); |
| if ((majorNumber & 0x3f0) == 0x3f0) { |
| // If the six MSBs are 111111, these indicate that there is only one-part channel |
| // number. To see details, refer A/65 Section 6.3.2. |
| majorNumber = ((majorNumber & 0xf) << 10) + minorNumber; |
| minorNumber = 0; |
| } |
| int channelTsid = ((data[pos + 22] & 0xff) << 8) | (data[pos + 23] & 0xff); |
| int programNumber = ((data[pos + 24] & 0xff) << 8) | (data[pos + 25] & 0xff); |
| boolean accessControlled = (data[pos + 26] & 0x20) != 0; |
| boolean hidden = (data[pos + 26] & 0x10) != 0; |
| int serviceType = (data[pos + 27] & 0x3f); |
| int sourceId = ((data[pos + 28] & 0xff) << 8) | (data[pos + 29] & 0xff); |
| int descriptorsPos = pos + 32; |
| int descriptorsLength = ((data[pos + 30] & 0x03) << 8) | (data[pos + 31] & 0xff); |
| pos += 32 + descriptorsLength; |
| if (data.length < pos) { |
| Log.e(TAG, "Broken VCT."); |
| return false; |
| } |
| List<TsDescriptor> descriptors = parseDescriptors( |
| data, descriptorsPos, descriptorsPos + descriptorsLength); |
| String longName = null; |
| for (TsDescriptor descriptor : descriptors) { |
| if (descriptor instanceof ExtendedChannelNameDescriptor) { |
| ExtendedChannelNameDescriptor extendedChannelNameDescriptor = |
| (ExtendedChannelNameDescriptor) descriptor; |
| longName = extendedChannelNameDescriptor.getLongChannelName(); |
| break; |
| } |
| } |
| if (DEBUG) { |
| Log.d(TAG, String.format( |
| "Found channel [%s] %s - serviceType: %d tsid: 0x%x program: %d " |
| + "channel: %d-%d encrypted: %b hidden: %b, descriptors: %d", |
| shortName, longName, serviceType, channelTsid, programNumber, majorNumber, |
| minorNumber, accessControlled, hidden, descriptors.size())); |
| } |
| if (!accessControlled && !hidden && (serviceType == Channel.SERVICE_TYPE_ATSC_AUDIO || |
| serviceType == Channel.SERVICE_TYPE_ATSC_DIGITAL_TELEVISION || |
| serviceType == Channel.SERVICE_TYPE_UNASSOCIATED_SMALL_SCREEN_SERVICE)) { |
| // Hide hidden, encrypted, or unsupported ATSC service type channels |
| results.add(new VctItem(shortName, longName, serviceType, channelTsid, |
| programNumber, majorNumber, minorNumber, sourceId)); |
| } |
| } |
| // Skip the remaining descriptor part which we don't use. |
| |
| if (mListener != null) { |
| mListener.onVctParsed(results, sectionNumber, lastSectionNumber); |
| } |
| return true; |
| } |
| |
| private boolean parseEIT(byte[] data) { |
| // For details of the structure for EIT, see ATSC A/65 Table 6.11. |
| if (DEBUG) { |
| Log.d(TAG, "EIT is discovered."); |
| } |
| if (data.length <= 9) { |
| Log.e(TAG, "Broken EIT."); |
| return false; |
| } |
| int sourceId = ((data[3] & 0xff) << 8) | (data[4] & 0xff); |
| int numEventsInSection = (data[9] & 0xff); |
| |
| int pos = 10; |
| List<EitItem> results = new ArrayList<>(); |
| for (int i = 0; i < numEventsInSection; ++i) { |
| if (data.length <= pos + 9) { |
| Log.e(TAG, "Broken EIT."); |
| return false; |
| } |
| if ((data[pos] & 0xc0) != 0xc0) { |
| Log.e(TAG, "Broken EIT."); |
| return false; |
| } |
| int eventId = ((data[pos] & 0x3f) << 8) + (data[pos + 1] & 0xff); |
| long startTime = ((data[pos + 2] & (long) 0xff) << 24) | ((data[pos + 3] & 0xff) << 16) |
| | ((data[pos + 4] & 0xff) << 8) | (data[pos + 5] & 0xff); |
| int lengthInSecond = ((data[pos + 6] & 0x0f) << 16) |
| | ((data[pos + 7] & 0xff) << 8) | (data[pos + 8] & 0xff); |
| int titleLength = (data[pos + 9] & 0xff); |
| if (data.length <= pos + 10 + titleLength + 1) { |
| Log.e(TAG, "Broken EIT."); |
| return false; |
| } |
| String titleText = ""; |
| if (titleLength > 0) { |
| titleText = extractText(data, pos + 10); |
| } |
| if ((data[pos + 10 + titleLength] & 0xf0) != 0xf0) { |
| Log.e(TAG, "Broken EIT."); |
| return false; |
| } |
| int descriptorsLength = ((data[pos + 10 + titleLength] & 0x0f) << 8) |
| | (data[pos + 10 + titleLength + 1] & 0xff); |
| int descriptorsPos = pos + 10 + titleLength + 2; |
| if (data.length < descriptorsPos + descriptorsLength) { |
| Log.e(TAG, "Broken EIT."); |
| return false; |
| } |
| List<TsDescriptor> descriptors = parseDescriptors( |
| data, descriptorsPos, descriptorsPos + descriptorsLength); |
| if (DEBUG) { |
| Log.d(TAG, String.format("EIT descriptors size: %d", descriptors.size())); |
| } |
| String contentRating = generateContentRating(descriptors); |
| String broadcastGenre = generateBroadcastGenre(descriptors); |
| String canonicalGenre = generateCanonicalGenre(descriptors); |
| List<AtscAudioTrack> audioTracks = generateAudioTracks(descriptors); |
| List<AtscCaptionTrack> captionTracks = generateCaptionTracks(descriptors); |
| pos += 10 + titleLength + 2 + descriptorsLength; |
| results.add(new EitItem(EitItem.INVALID_PROGRAM_ID, eventId, titleText, |
| startTime, lengthInSecond, contentRating, audioTracks, captionTracks, |
| broadcastGenre, canonicalGenre, null)); |
| } |
| if (mListener != null) { |
| mListener.onEitParsed(sourceId, results); |
| } |
| return true; |
| } |
| |
| private boolean parseETT(byte[] data) { |
| // For details of the structure for ETT, see ATSC A/65 Table 6.13. |
| if (DEBUG) { |
| Log.d(TAG, "ETT is discovered."); |
| } |
| if (data.length <= 12) { |
| Log.e(TAG, "Broken ETT."); |
| return false; |
| } |
| int sourceId = ((data[9] & 0xff) << 8) | (data[10] & 0xff); |
| int eventId = (((data[11] & 0xff) << 8) | (data[12] & 0xff)) >> 2; |
| String text = extractText(data, 13); |
| List<EttItem> ettItems = mParsedEttItems.get(sourceId); |
| if (ettItems == null) { |
| ettItems = new ArrayList<>(); |
| mParsedEttItems.put(sourceId, ettItems); |
| } |
| ettItems.add(new EttItem(eventId, text)); |
| return true; |
| } |
| |
| private boolean parseSDT(byte[] data) { |
| // For details of the structure for SDT, see DVB Document A038 Table 5. |
| if (DEBUG) { |
| Log.d(TAG, "SDT id discovered"); |
| } |
| if (data.length <= 11) { |
| Log.e(TAG, "Broken SDT."); |
| return false; |
| } |
| if ((data[1] & 0x80) >> 7 != 1) { |
| Log.e(TAG, "Broken SDT, section syntax indicator error."); |
| return false; |
| } |
| int sectionLength = ((data[1] & 0x0f) << 8) | (data[2] & 0xff); |
| int transportStreamId = ((data[3] & 0xff) << 8) | (data[4] & 0xff); |
| int originalNetworkId = ((data[8] & 0xff) << 8) | (data[9] & 0xff); |
| int pos = 11; |
| if (sectionLength + 3 > data.length) { |
| Log.e(TAG, "Broken SDT."); |
| } |
| List<SdtItem> sdtItems = new ArrayList<>(); |
| while (pos + 9 < data.length) { |
| int serviceId = ((data[pos] & 0xff) << 8) | (data[pos + 1] & 0xff); |
| int descriptorsLength = ((data[pos + 3] & 0x0f) << 8) | (data[pos + 4] & 0xff); |
| pos += 5; |
| List<TsDescriptor> descriptors = parseDescriptors(data, pos, pos + descriptorsLength); |
| List<ServiceDescriptor> serviceDescriptors = generateServiceDescriptors(descriptors); |
| String serviceName = ""; |
| String serviceProviderName = ""; |
| int serviceType = 0; |
| for (ServiceDescriptor serviceDescriptor : serviceDescriptors) { |
| serviceName = serviceDescriptor.getServiceName(); |
| serviceProviderName = serviceDescriptor.getServiceProviderName(); |
| serviceType = serviceDescriptor.getServiceType(); |
| } |
| if (serviceDescriptors.size() > 0) { |
| sdtItems.add(new SdtItem(serviceName, serviceProviderName, serviceType, serviceId, |
| originalNetworkId)); |
| } |
| pos += descriptorsLength; |
| } |
| if (mListener != null) { |
| mListener.onSdtParsed(sdtItems); |
| } |
| return true; |
| } |
| |
| private boolean parseDVBEIT(byte[] data) { |
| // For details of the structure for DVB ETT, see DVB Document A038 Table 7. |
| if (DEBUG) { |
| Log.d(TAG, "DVB EIT is discovered."); |
| } |
| if (data.length < 18) { |
| Log.e(TAG, "Broken DVB EIT."); |
| return false; |
| } |
| int sectionLength = ((data[1] & 0x0f) << 8) | (data[2] & 0xff); |
| int sourceId = ((data[3] & 0xff) << 8) | (data[4] & 0xff); |
| int transportStreamId = ((data[8] & 0xff) << 8) | (data[9] & 0xff); |
| int originalNetworkId = ((data[10] & 0xff) << 8) | (data[11] & 0xff); |
| |
| int pos = 14; |
| List<EitItem> results = new ArrayList<>(); |
| while (pos + 12 < data.length) { |
| int eventId = ((data[pos] & 0xff) << 8) + (data[pos + 1] & 0xff); |
| float modifiedJulianDate = ((data[pos + 2] & 0xff) << 8) | (data[pos + 3] & 0xff); |
| int startYear = (int) ((modifiedJulianDate - 15078.2f) / 365.25f); |
| int mjdMonth = (int) ((modifiedJulianDate - 14956.1f |
| - (int) (startYear * 365.25f)) / 30.6001f); |
| int startDay = (int) modifiedJulianDate - 14956 - (int) (startYear * 365.25f) |
| - (int) (mjdMonth * 30.6001f); |
| int startMonth = mjdMonth - 1; |
| if (mjdMonth == 14 || mjdMonth == 15) { |
| startYear += 1; |
| startMonth -= 12; |
| } |
| int startHour = ((data[pos + 4] & 0xf0) >> 4) * 10 + (data[pos + 4] & 0x0f); |
| int startMinute = ((data[pos + 5] & 0xf0) >> 4) * 10 + (data[pos + 5] & 0x0f); |
| int startSecond = ((data[pos + 6] & 0xf0) >> 4) * 10 + (data[pos + 6] & 0x0f); |
| Calendar calendar = Calendar.getInstance(); |
| startYear += 1900; |
| calendar.set(startYear, startMonth, startDay, startHour, startMinute, startSecond); |
| long startTime = ConvertUtils.convertUnixEpochToGPSTime( |
| calendar.getTimeInMillis() / 1000); |
| int durationInSecond = (((data[pos + 7] & 0xf0) >> 4) * 10 |
| + (data[pos + 7] & 0x0f)) * 3600 |
| + (((data[pos + 8] & 0xf0) >> 4) * 10 + (data[pos + 8] & 0x0f)) * 60 |
| + (((data[pos + 9] & 0xf0) >> 4) * 10 + (data[pos + 9] & 0x0f)); |
| int descriptorsLength = ((data[pos + 10] & 0x0f) << 8) |
| | (data[pos + 10 + 1] & 0xff); |
| int descriptorsPos = pos + 10 + 2; |
| if (data.length < descriptorsPos + descriptorsLength) { |
| Log.e(TAG, "Broken EIT."); |
| return false; |
| } |
| List<TsDescriptor> descriptors = parseDescriptors( |
| data, descriptorsPos, descriptorsPos + descriptorsLength); |
| if (DEBUG) { |
| Log.d(TAG, String.format("DVB EIT descriptors size: %d", descriptors.size())); |
| } |
| // TODO: Add logic to generating content rating for dvb. See DVB document 6.2.28 for |
| // details. Content rating here will be null |
| String contentRating = generateContentRating(descriptors); |
| // TODO: Add logic for generating genre for dvb. See DVB document 6.2.9 for details. |
| // Genre here will be null here. |
| String broadcastGenre = generateBroadcastGenre(descriptors); |
| String canonicalGenre = generateCanonicalGenre(descriptors); |
| String titleText = generateShortEventName(descriptors); |
| List<AtscAudioTrack> audioTracks = generateAudioTracks(descriptors); |
| List<AtscCaptionTrack> captionTracks = generateCaptionTracks(descriptors); |
| pos += 12 + descriptorsLength; |
| results.add(new EitItem(EitItem.INVALID_PROGRAM_ID, eventId, titleText, |
| startTime, durationInSecond, contentRating, audioTracks, captionTracks, |
| broadcastGenre, canonicalGenre, null)); |
| } |
| if (mListener != null) { |
| mListener.onEitParsed(sourceId, results); |
| } |
| return true; |
| } |
| |
| private static List<AtscAudioTrack> generateAudioTracks(List<TsDescriptor> descriptors) { |
| // The list of audio tracks sent is located at both AC3 Audio descriptor and ISO 639 |
| // Language descriptor. |
| List<AtscAudioTrack> ac3Tracks = new ArrayList<>(); |
| List<AtscAudioTrack> iso639LanguageTracks = new ArrayList<>(); |
| for (TsDescriptor descriptor : descriptors) { |
| if (descriptor instanceof Ac3AudioDescriptor) { |
| Ac3AudioDescriptor audioDescriptor = |
| (Ac3AudioDescriptor) descriptor; |
| AtscAudioTrack audioTrack = new AtscAudioTrack(); |
| if (audioDescriptor.getLanguage() != null) { |
| audioTrack.language = audioDescriptor.getLanguage(); |
| } |
| if (audioTrack.language == null) { |
| audioTrack.language = ""; |
| } |
| audioTrack.audioType = AtscAudioTrack.AUDIOTYPE_UNDEFINED; |
| audioTrack.channelCount = audioDescriptor.getNumChannels(); |
| audioTrack.sampleRate = audioDescriptor.getSampleRate(); |
| ac3Tracks.add(audioTrack); |
| } |
| } |
| for (TsDescriptor descriptor : descriptors) { |
| if (descriptor instanceof Iso639LanguageDescriptor) { |
| Iso639LanguageDescriptor iso639LanguageDescriptor = |
| (Iso639LanguageDescriptor) descriptor; |
| iso639LanguageTracks.addAll(iso639LanguageDescriptor.getAudioTracks()); |
| } |
| } |
| |
| // An AC3 audio stream descriptor only has a audio channel count and a audio sample rate |
| // while a ISO 639 Language descriptor only has a audio type, which describes a main use |
| // case of its audio track. |
| // Some channels contain only AC3 audio stream descriptors with valid language values. |
| // Other channels contain both an AC3 audio stream descriptor and a ISO 639 Language |
| // descriptor per audio track, and those AC3 audio stream descriptors often have a null |
| // value of language field. |
| // Combines two descriptors into one in order to gather more audio track specific |
| // information as much as possible. |
| List<AtscAudioTrack> tracks = new ArrayList<>(); |
| if (!ac3Tracks.isEmpty() && !iso639LanguageTracks.isEmpty() |
| && ac3Tracks.size() != iso639LanguageTracks.size()) { |
| // This shouldn't be happen. In here, it handles two cases. The first case is that the |
| // only one type of descriptors arrives. The second case is that the two types of |
| // descriptors have the same number of tracks. |
| Log.e(TAG, "AC3 audio stream descriptors size != ISO 639 Language descriptors size"); |
| return tracks; |
| } |
| int size = Math.max(ac3Tracks.size(), iso639LanguageTracks.size()); |
| for (int i = 0; i < size; ++i) { |
| AtscAudioTrack audioTrack = null; |
| if (i < ac3Tracks.size()) { |
| audioTrack = ac3Tracks.get(i); |
| } |
| if (i < iso639LanguageTracks.size()) { |
| if (audioTrack == null) { |
| audioTrack = iso639LanguageTracks.get(i); |
| } else { |
| AtscAudioTrack iso639LanguageTrack = iso639LanguageTracks.get(i); |
| if (audioTrack.language == null || TextUtils.equals(audioTrack.language, "")) { |
| audioTrack.language = iso639LanguageTrack.language; |
| } |
| audioTrack.audioType = iso639LanguageTrack.audioType; |
| } |
| } |
| String language = ISO_LANGUAGE_CODE_MAP.get(audioTrack.language); |
| if (language != null) { |
| audioTrack.language = language; |
| } |
| tracks.add(audioTrack); |
| } |
| return tracks; |
| } |
| |
| private static List<AtscCaptionTrack> generateCaptionTracks(List<TsDescriptor> descriptors) { |
| List<AtscCaptionTrack> services = new ArrayList<>(); |
| for (TsDescriptor descriptor : descriptors) { |
| if (descriptor instanceof CaptionServiceDescriptor) { |
| CaptionServiceDescriptor captionServiceDescriptor = |
| (CaptionServiceDescriptor) descriptor; |
| services.addAll(captionServiceDescriptor.getCaptionTracks()); |
| } |
| } |
| return services; |
| } |
| |
| @VisibleForTesting |
| static String generateContentRating(List<TsDescriptor> descriptors) { |
| Set<String> contentRatings = new ArraySet<>(); |
| List<RatingRegion> usRatingRegions = getRatingRegions(descriptors, RATING_REGION_US_TV); |
| List<RatingRegion> krRatingRegions = getRatingRegions(descriptors, RATING_REGION_KR_TV); |
| for (RatingRegion region : usRatingRegions) { |
| String contentRating = getUsRating(region); |
| if (contentRating != null) { |
| contentRatings.add(contentRating); |
| } |
| } |
| for (RatingRegion region : krRatingRegions) { |
| String contentRating = getKrRating(region); |
| if (contentRating != null) { |
| contentRatings.add(contentRating); |
| } |
| } |
| return TextUtils.join(",", contentRatings); |
| } |
| |
| /** |
| * Gets a list of {@link RatingRegion} in the specific region. |
| * |
| * @param descriptors {@link TsDescriptor} list which may contains rating information |
| * @param region the specific region |
| * @return a list of {@link RatingRegion} in the specific region |
| */ |
| private static List<RatingRegion> getRatingRegions(List<TsDescriptor> descriptors, int region) { |
| List<RatingRegion> ratingRegions = new ArrayList<>(); |
| for (TsDescriptor descriptor : descriptors) { |
| if (!(descriptor instanceof ContentAdvisoryDescriptor)) { |
| continue; |
| } |
| ContentAdvisoryDescriptor contentAdvisoryDescriptor = |
| (ContentAdvisoryDescriptor) descriptor; |
| for (RatingRegion ratingRegion : contentAdvisoryDescriptor.getRatingRegions()) { |
| if (ratingRegion.getName() == region) { |
| ratingRegions.add(ratingRegion); |
| } |
| } |
| } |
| return ratingRegions; |
| } |
| |
| /** |
| * Gets US content rating and subratings (if any). |
| * |
| * @param ratingRegion a {@link RatingRegion} instance which may contain rating information. |
| * @return A string representing the US content rating and subratings. The format of the string |
| * is defined in {@link TvContentRating}. null, if no such a string exists. |
| */ |
| private static String getUsRating(RatingRegion ratingRegion) { |
| if (ratingRegion.getName() != RATING_REGION_US_TV) { |
| return null; |
| } |
| List<RegionalRating> regionalRatings = ratingRegion.getRegionalRatings(); |
| String rating = null; |
| int ratingIndex = VALUE_US_TV_NONE; |
| List<String> subratings = new ArrayList<>(); |
| for (RegionalRating index : regionalRatings) { |
| // See Table 3 of ANSI-CEA-766-D |
| int dimension = index.getDimension(); |
| int value = index.getRating(); |
| switch (dimension) { |
| // According to Table 6.27 of ATSC A65, |
| // the dimensions shall be in increasing order. |
| // Therefore, rating and ratingIndex are assigned before any corresponding |
| // subrating. |
| case DIMENSION_US_TV_RATING: |
| if (value >= VALUE_US_TV_G && value < RATING_REGION_TABLE_US_TV.length) { |
| rating = RATING_REGION_TABLE_US_TV[value]; |
| ratingIndex = value; |
| } |
| break; |
| case DIMENSION_US_TV_D: |
| if (value == 1 |
| && (ratingIndex == VALUE_US_TV_PG || ratingIndex == VALUE_US_TV_14)) { |
| // US_TV_D is applicable to US_TV_PG and US_TV_14 |
| subratings.add(RATING_REGION_TABLE_US_TV_SUBRATING[dimension - 1]); |
| } |
| break; |
| case DIMENSION_US_TV_L: |
| case DIMENSION_US_TV_S: |
| case DIMENSION_US_TV_V: |
| if (value == 1 |
| && ratingIndex >= VALUE_US_TV_PG |
| && ratingIndex <= VALUE_US_TV_MA) { |
| // US_TV_L, US_TV_S, and US_TV_V are applicable to |
| // US_TV_PG, US_TV_14 and US_TV_MA |
| subratings.add(RATING_REGION_TABLE_US_TV_SUBRATING[dimension - 1]); |
| } |
| break; |
| case DIMENSION_US_TV_Y: |
| if (rating == null) { |
| if (value == VALUE_US_TV_Y) { |
| rating = STRING_US_TV_Y; |
| } else if (value == VALUE_US_TV_Y7) { |
| rating = STRING_US_TV_Y7; |
| } |
| } |
| break; |
| case DIMENSION_US_TV_FV: |
| if (STRING_US_TV_Y7.equals(rating) && value == 1) { |
| // US_TV_FV is applicable to US_TV_Y7 |
| subratings.add(STRING_US_TV_FV); |
| } |
| break; |
| case DIMENSION_US_MV_RATING: |
| if (value >= VALUE_US_MV_G && value <= VALUE_US_MV_X) { |
| if (value == VALUE_US_MV_X) { |
| // US_MV_X was replaced by US_MV_NC17 in 1990, |
| // and it's not supported by TvContentRating |
| value = VALUE_US_MV_NC17; |
| } |
| if (rating != null) { |
| // According to Table 3 of ANSI-CEA-766-D, |
| // DIMENSION_US_TV_RATING and DIMENSION_US_MV_RATING shall not be |
| // present in the same descriptor. |
| Log.w( |
| TAG, |
| "DIMENSION_US_TV_RATING and DIMENSION_US_MV_RATING are " |
| + "present in the same descriptor"); |
| } else { |
| return TvContentRating.createRating( |
| RATING_DOMAIN, |
| RATING_REGION_RATING_SYSTEM_US_MV, |
| RATING_REGION_TABLE_US_MV[value - 2]) |
| .flattenToString(); |
| } |
| } |
| break; |
| |
| default: |
| break; |
| } |
| } |
| if (rating == null) { |
| return null; |
| } |
| |
| String[] subratingArray = subratings.toArray(new String[subratings.size()]); |
| return TvContentRating.createRating( |
| RATING_DOMAIN, RATING_REGION_RATING_SYSTEM_US_TV, rating, subratingArray) |
| .flattenToString(); |
| } |
| |
| /** |
| * Gets KR(South Korea) content rating. |
| * |
| * @param ratingRegion a {@link RatingRegion} instance which may contain rating information. |
| * @return A string representing the KR content rating. The format of the string is defined in |
| * {@link TvContentRating}. null, if no such a string exists. |
| */ |
| private static String getKrRating(RatingRegion ratingRegion) { |
| if (ratingRegion.getName() != RATING_REGION_KR_TV) { |
| return null; |
| } |
| List<RegionalRating> regionalRatings = ratingRegion.getRegionalRatings(); |
| String rating = null; |
| for (RegionalRating index : regionalRatings) { |
| if (index.getDimension() == 0 |
| && index.getRating() >= 0 |
| && index.getRating() < RATING_REGION_TABLE_KR_TV.length) { |
| rating = RATING_REGION_TABLE_KR_TV[index.getRating()]; |
| break; |
| } |
| } |
| if (rating == null) { |
| return null; |
| } |
| return TvContentRating.createRating( |
| RATING_DOMAIN, RATING_REGION_RATING_SYSTEM_KR_TV, rating) |
| .flattenToString(); |
| } |
| |
| private static String generateBroadcastGenre(List<TsDescriptor> descriptors) { |
| for (TsDescriptor descriptor : descriptors) { |
| if (descriptor instanceof GenreDescriptor) { |
| GenreDescriptor genreDescriptor = |
| (GenreDescriptor) descriptor; |
| return TextUtils.join(",", genreDescriptor.getBroadcastGenres()); |
| } |
| } |
| return null; |
| } |
| |
| private static String generateCanonicalGenre(List<TsDescriptor> descriptors) { |
| for (TsDescriptor descriptor : descriptors) { |
| if (descriptor instanceof GenreDescriptor) { |
| GenreDescriptor genreDescriptor = |
| (GenreDescriptor) descriptor; |
| return Genres.encode(genreDescriptor.getCanonicalGenres()); |
| } |
| } |
| return null; |
| } |
| |
| private static List<ServiceDescriptor> generateServiceDescriptors( |
| List<TsDescriptor> descriptors) { |
| List<ServiceDescriptor> serviceDescriptors = new ArrayList<>(); |
| for (TsDescriptor descriptor : descriptors) { |
| if (descriptor instanceof ServiceDescriptor) { |
| ServiceDescriptor serviceDescriptor = (ServiceDescriptor) descriptor; |
| serviceDescriptors.add(serviceDescriptor); |
| } |
| } |
| return serviceDescriptors; |
| } |
| |
| private static String generateShortEventName(List<TsDescriptor> descriptors) { |
| for (TsDescriptor descriptor : descriptors) { |
| if (descriptor instanceof ShortEventDescriptor) { |
| ShortEventDescriptor shortEventDescriptor = (ShortEventDescriptor) descriptor; |
| return shortEventDescriptor.getEventName(); |
| } |
| } |
| return ""; |
| } |
| |
| private static List<TsDescriptor> parseDescriptors(byte[] data, int offset, int limit) { |
| // For details of the structure for descriptors, see ATSC A/65 Section 6.9. |
| List<TsDescriptor> descriptors = new ArrayList<>(); |
| if (data.length < limit) { |
| return descriptors; |
| } |
| int pos = offset; |
| while (pos + 1 < limit) { |
| int tag = data[pos] & 0xff; |
| int length = data[pos + 1] & 0xff; |
| if (length <= 0) { |
| break; |
| } |
| if (limit < pos + length + 2) { |
| break; |
| } |
| if (DEBUG) { |
| Log.d(TAG, String.format("Descriptor tag: %02x", tag)); |
| } |
| TsDescriptor descriptor = null; |
| switch (tag) { |
| case DESCRIPTOR_TAG_CONTENT_ADVISORY: |
| descriptor = parseContentAdvisory(data, pos, pos + length + 2); |
| break; |
| |
| case DESCRIPTOR_TAG_CAPTION_SERVICE: |
| descriptor = parseCaptionService(data, pos, pos + length + 2); |
| break; |
| |
| case DESCRIPTOR_TAG_EXTENDED_CHANNEL_NAME: |
| descriptor = parseLongChannelName(data, pos, pos + length + 2); |
| break; |
| |
| case DESCRIPTOR_TAG_GENRE: |
| descriptor = parseGenre(data, pos, pos + length + 2); |
| break; |
| |
| case DESCRIPTOR_TAG_AC3_AUDIO_STREAM: |
| descriptor = parseAc3AudioStream(data, pos, pos + length + 2); |
| break; |
| |
| case DESCRIPTOR_TAG_ISO639LANGUAGE: |
| descriptor = parseIso639Language(data, pos, pos + length + 2); |
| break; |
| |
| case DVB_DESCRIPTOR_TAG_SERVICE: |
| descriptor = parseDvbService(data, pos, pos + length + 2); |
| break; |
| |
| case DVB_DESCRIPTOR_TAG_SHORT_EVENT: |
| descriptor = parseDvbShortEvent(data, pos, pos + length + 2); |
| break; |
| |
| case DVB_DESCRIPTOR_TAG_CONTENT: |
| descriptor = parseDvbContent(data, pos, pos + length + 2); |
| break; |
| |
| case DVB_DESCRIPTOR_TAG_PARENTAL_RATING: |
| descriptor = parseDvbParentalRating(data, pos, pos + length + 2); |
| break; |
| |
| default: |
| } |
| if (descriptor != null) { |
| if (DEBUG) { |
| Log.d(TAG, "Descriptor parsed: " + descriptor); |
| } |
| descriptors.add(descriptor); |
| } |
| pos += length + 2; |
| } |
| return descriptors; |
| } |
| |
| private static Iso639LanguageDescriptor parseIso639Language(byte[] data, int pos, int limit) { |
| // For the details of the structure of ISO 639 language descriptor, |
| // see ISO13818-1 second edition Section 2.6.18. |
| pos += 2; |
| List<AtscAudioTrack> audioTracks = new ArrayList<>(); |
| while (pos + 4 <= limit) { |
| if (limit <= pos + 3) { |
| Log.e(TAG, "Broken Iso639Language."); |
| return null; |
| } |
| String language = new String(data, pos, 3); |
| int audioType = data[pos + 3] & 0xff; |
| AtscAudioTrack audioTrack = new AtscAudioTrack(); |
| audioTrack.language = language; |
| audioTrack.audioType = audioType; |
| audioTracks.add(audioTrack); |
| pos += 4; |
| } |
| return new Iso639LanguageDescriptor(audioTracks); |
| } |
| |
| private static CaptionServiceDescriptor parseCaptionService(byte[] data, int pos, int limit) { |
| // For the details of the structure of caption service descriptor, |
| // see ATSC A/65 Section 6.9.2. |
| if (limit <= pos + 2) { |
| Log.e(TAG, "Broken CaptionServiceDescriptor."); |
| return null; |
| } |
| List<AtscCaptionTrack> services = new ArrayList<>(); |
| pos += 2; |
| int numberServices = data[pos] & 0x1f; |
| ++pos; |
| if (limit < pos + numberServices * 6) { |
| Log.e(TAG, "Broken CaptionServiceDescriptor."); |
| return null; |
| } |
| for (int i = 0; i < numberServices; ++i) { |
| String language = new String(Arrays.copyOfRange(data, pos, pos + 3)); |
| pos += 3; |
| boolean ccType = (data[pos] & 0x80) != 0; |
| if (!ccType) { |
| pos +=3; |
| continue; |
| } |
| int captionServiceNumber = data[pos] & 0x3f; |
| ++pos; |
| boolean easyReader = (data[pos] & 0x80) != 0; |
| boolean wideAspectRatio = (data[pos] & 0x40) != 0; |
| byte[] reserved = new byte[2]; |
| reserved[0] = (byte) (data[pos] << 2); |
| reserved[0] |= (byte) ((data[pos + 1] & 0xc0) >>> 6); |
| reserved[1] = (byte) ((data[pos + 1] & 0x3f) << 2); |
| pos += 2; |
| AtscCaptionTrack captionTrack = new AtscCaptionTrack(); |
| captionTrack.language = language; |
| captionTrack.serviceNumber = captionServiceNumber; |
| captionTrack.easyReader = easyReader; |
| captionTrack.wideAspectRatio = wideAspectRatio; |
| services.add(captionTrack); |
| } |
| return new CaptionServiceDescriptor(services); |
| } |
| |
| private static ContentAdvisoryDescriptor parseContentAdvisory(byte[] data, int pos, int limit) { |
| // For details of the structure for content advisory descriptor, see A/65 Table 6.27. |
| if (limit <= pos + 2) { |
| Log.e(TAG, "Broken ContentAdvisory"); |
| return null; |
| } |
| int count = data[pos + 2] & 0x3f; |
| pos += 3; |
| List<RatingRegion> ratingRegions = new ArrayList<>(); |
| for (int i = 0; i < count; ++i) { |
| if (limit <= pos + 1) { |
| Log.e(TAG, "Broken ContentAdvisory"); |
| return null; |
| } |
| List<RegionalRating> indices = new ArrayList<>(); |
| int ratingRegion = data[pos] & 0xff; |
| int dimensionCount = data[pos + 1] & 0xff; |
| pos += 2; |
| int previousDimension = -1; |
| for (int j = 0; j < dimensionCount; ++j) { |
| if (limit <= pos + 1) { |
| Log.e(TAG, "Broken ContentAdvisory"); |
| return null; |
| } |
| int dimensionIndex = data[pos] & 0xff; |
| int ratingValue = data[pos + 1] & 0x0f; |
| if (dimensionIndex <= previousDimension) { |
| // According to Table 6.27 of ATSC A65, |
| // the indices shall be in increasing order. |
| Log.e(TAG, "Broken ContentAdvisory"); |
| return null; |
| } |
| previousDimension = dimensionIndex; |
| pos += 2; |
| indices.add(new RegionalRating(dimensionIndex, ratingValue)); |
| } |
| if (limit <= pos) { |
| Log.e(TAG, "Broken ContentAdvisory"); |
| return null; |
| } |
| int ratingDescriptionLength = data[pos] & 0xff; |
| ++pos; |
| if (limit < pos + ratingDescriptionLength) { |
| Log.e(TAG, "Broken ContentAdvisory"); |
| return null; |
| } |
| String ratingDescription = extractText(data, pos); |
| pos += ratingDescriptionLength; |
| ratingRegions.add(new RatingRegion(ratingRegion, ratingDescription, indices)); |
| } |
| return new ContentAdvisoryDescriptor(ratingRegions); |
| } |
| |
| private static ExtendedChannelNameDescriptor parseLongChannelName(byte[] data, int pos, |
| int limit) { |
| if (limit <= pos + 2) { |
| Log.e(TAG, "Broken ExtendedChannelName."); |
| return null; |
| } |
| pos += 2; |
| String text = extractText(data, pos); |
| if (text == null) { |
| Log.e(TAG, "Broken ExtendedChannelName."); |
| return null; |
| } |
| return new ExtendedChannelNameDescriptor(text); |
| } |
| |
| private static GenreDescriptor parseGenre(byte[] data, int pos, int limit) { |
| pos += 2; |
| int attributeCount = data[pos] & 0x1f; |
| if (limit <= pos + attributeCount) { |
| Log.e(TAG, "Broken Genre."); |
| return null; |
| } |
| HashSet<String> broadcastGenreSet = new HashSet<>(); |
| HashSet<String> canonicalGenreSet = new HashSet<>(); |
| for (int i = 0; i < attributeCount; ++i) { |
| ++pos; |
| int genreCode = data[pos] & 0xff; |
| if (genreCode < BROADCAST_GENRES_TABLE.length) { |
| String broadcastGenre = BROADCAST_GENRES_TABLE[genreCode]; |
| if (broadcastGenre != null && !broadcastGenreSet.contains(broadcastGenre)) { |
| broadcastGenreSet.add(broadcastGenre); |
| } |
| } |
| if (genreCode < CANONICAL_GENRES_TABLE.length) { |
| String canonicalGenre = CANONICAL_GENRES_TABLE[genreCode]; |
| if (canonicalGenre != null && !canonicalGenreSet.contains(canonicalGenre)) { |
| canonicalGenreSet.add(canonicalGenre); |
| } |
| } |
| } |
| return new GenreDescriptor(broadcastGenreSet.toArray(new String[broadcastGenreSet.size()]), |
| canonicalGenreSet.toArray(new String[canonicalGenreSet.size()])); |
| } |
| |
| private static TsDescriptor parseAc3AudioStream(byte[] data, int pos, int limit) { |
| // For details of the AC3 audio stream descriptor, see A/52 Table A4.1. |
| if (limit <= pos + 5) { |
| Log.e(TAG, "Broken AC3 audio stream descriptor."); |
| return null; |
| } |
| pos += 2; |
| byte sampleRateCode = (byte) ((data[pos] & 0xe0) >> 5); |
| byte bsid = (byte) (data[pos] & 0x1f); |
| ++pos; |
| byte bitRateCode = (byte) ((data[pos] & 0xfc) >> 2); |
| byte surroundMode = (byte) (data[pos] & 0x03); |
| ++pos; |
| byte bsmod = (byte) ((data[pos] & 0xe0) >> 5); |
| int numChannels = (data[pos] & 0x1e) >> 1; |
| boolean fullSvc = (data[pos] & 0x01) != 0; |
| ++pos; |
| byte langCod = data[pos]; |
| byte langCod2 = 0; |
| if (numChannels == 0) { |
| if (limit <= pos) { |
| Log.e(TAG, "Broken AC3 audio stream descriptor."); |
| return null; |
| } |
| ++pos; |
| langCod2 = data[pos]; |
| } |
| if (limit <= pos + 1) { |
| Log.e(TAG, "Broken AC3 audio stream descriptor."); |
| return null; |
| } |
| byte mainId = 0; |
| byte priority = 0; |
| byte asvcflags = 0; |
| ++pos; |
| if (bsmod < 2) { |
| mainId = (byte) ((data[pos] & 0xe0) >> 5); |
| priority = (byte) ((data[pos] & 0x18) >> 3); |
| if ((data[pos] & 0x07) != 0x07) { |
| Log.e(TAG, "Broken AC3 audio stream descriptor reserved failed"); |
| return null; |
| } |
| } else { |
| asvcflags = data[pos]; |
| } |
| |
| // See A/52B Table A3.6 num_channels. |
| int numEncodedChannels; |
| switch (numChannels) { |
| case 1: |
| case 8: |
| numEncodedChannels = 1; |
| break; |
| case 2: |
| case 9: |
| numEncodedChannels = 2; |
| break; |
| case 3: |
| case 4: |
| case 10: |
| numEncodedChannels = 3; |
| break; |
| case 5: |
| case 6: |
| case 11: |
| numEncodedChannels = 4; |
| break; |
| case 7: |
| case 12: |
| numEncodedChannels = 5; |
| break; |
| case 13: |
| numEncodedChannels = 6; |
| break; |
| default: |
| numEncodedChannels = 0; |
| break; |
| } |
| |
| if (limit <= pos + 1) { |
| Log.w(TAG, "Missing text and language fields on AC3 audio stream descriptor."); |
| return new Ac3AudioDescriptor(sampleRateCode, bsid, bitRateCode, surroundMode, bsmod, |
| numEncodedChannels, fullSvc, langCod, langCod2, mainId, priority, asvcflags, |
| null, null, null); |
| } |
| ++pos; |
| int textLen = (data[pos] & 0xfe) >> 1; |
| boolean textCode = (data[pos] & 0x01) != 0; |
| ++pos; |
| String text = ""; |
| if (textLen > 0) { |
| if (limit < pos + textLen) { |
| Log.e(TAG, "Broken AC3 audio stream descriptor"); |
| return null; |
| } |
| if (textCode) { |
| text = new String(data, pos, textLen); |
| } else { |
| text = new String(data, pos, textLen, Charset.forName("UTF-16")); |
| } |
| pos += textLen; |
| } |
| String language = null; |
| String language2 = null; |
| if (pos < limit) { |
| // Many AC3 audio stream descriptors skip the language fields. |
| boolean languageFlag1 = (data[pos] & 0x80) != 0; |
| boolean languageFlag2 = (data[pos] & 0x40) != 0; |
| if ((data[pos] & 0x3f) != 0x3f) { |
| Log.e(TAG, "Broken AC3 audio stream descriptor"); |
| return null; |
| } |
| if (pos + (languageFlag1 ? 3 : 0) + (languageFlag2 ? 3 : 0) > limit) { |
| Log.e(TAG, "Broken AC3 audio stream descriptor"); |
| return null; |
| } |
| ++pos; |
| if (languageFlag1) { |
| language = new String(data, pos, 3); |
| pos += 3; |
| } |
| if (languageFlag2) { |
| language2 = new String(data, pos, 3); |
| } |
| } |
| |
| return new Ac3AudioDescriptor(sampleRateCode, bsid, bitRateCode, surroundMode, bsmod, |
| numEncodedChannels, fullSvc, langCod, langCod2, mainId, priority, asvcflags, text, |
| language, language2); |
| } |
| |
| private static TsDescriptor parseDvbService(byte[] data, int pos, int limit) { |
| // For details of DVB service descriptors, see DVB Document A038 Table 86. |
| if (limit < pos + 5) { |
| Log.e(TAG, "Broken service descriptor."); |
| return null; |
| } |
| pos += 2; |
| int serviceType = data[pos] & 0xff; |
| pos++; |
| int serviceProviderNameLength = data[pos] & 0xff; |
| pos++; |
| String serviceProviderName = extractTextFromDvb(data, pos, serviceProviderNameLength); |
| pos += serviceProviderNameLength; |
| int serviceNameLength = data[pos] & 0xff; |
| pos++; |
| String serviceName = extractTextFromDvb(data, pos, serviceNameLength); |
| return new ServiceDescriptor(serviceType, serviceProviderName, serviceName); |
| } |
| |
| private static TsDescriptor parseDvbShortEvent(byte[] data, int pos, int limit) { |
| // For details of DVB service descriptors, see DVB Document A038 Table 91. |
| if (limit < pos + 7) { |
| Log.e(TAG, "Broken short event descriptor."); |
| return null; |
| } |
| pos += 2; |
| String language = new String(data, pos, 3); |
| int eventNameLength = data[pos + 3] & 0xff; |
| pos += 4; |
| if (pos + eventNameLength > limit) { |
| Log.e(TAG, "Broken short event descriptor."); |
| return null; |
| } |
| String eventName = new String(data, pos, eventNameLength); |
| pos += eventNameLength; |
| int textLength = data[pos] & 0xff; |
| if (pos + textLength > limit) { |
| Log.e(TAG, "Broken short event descriptor."); |
| return null; |
| } |
| pos++; |
| String text = new String(data, pos, textLength); |
| return new ShortEventDescriptor(language, eventName, text); |
| } |
| |
| private static TsDescriptor parseDvbContent(byte[] data, int pos, int limit) { |
| // TODO: According to DVB Document A038 Table 27 to add a parser for content descriptor to |
| // get content genre. |
| return null; |
| } |
| |
| private static TsDescriptor parseDvbParentalRating(byte[] data, int pos, int limit) { |
| // For details of DVB service descriptors, see DVB Document A038 Table 81. |
| HashMap<String, Integer> ratings = new HashMap<>(); |
| pos += 2; |
| while (pos + 4 <= limit) { |
| String countryCode = new String(data, pos, 3); |
| int rating = data[pos + 3] & 0xff; |
| pos += 4; |
| if (rating > 15) { |
| // Rating > 15 means that the ratings is defined by broadcaster. |
| continue; |
| } |
| ratings.put(countryCode, rating + 3); |
| } |
| return new ParentalRatingDescriptor(ratings); |
| } |
| |
| private static int getShortNameSize(byte[] data, int offset) { |
| for (int i = 0; i < MAX_SHORT_NAME_BYTES; i += 2) { |
| if (data[offset + i] == 0 && data[offset + i + 1] == 0) { |
| return i; |
| } |
| } |
| return MAX_SHORT_NAME_BYTES; |
| } |
| |
| private static String extractText(byte[] data, int pos) { |
| if (data.length < pos) { |
| return null; |
| } |
| int numStrings = data[pos] & 0xff; |
| pos++; |
| for (int i = 0; i < numStrings; ++i) { |
| if (data.length <= pos + 3) { |
| Log.e(TAG, "Broken text."); |
| return null; |
| } |
| int numSegments = data[pos + 3] & 0xff; |
| pos += 4; |
| for (int j = 0; j < numSegments; ++j) { |
| if (data.length <= pos + 2) { |
| Log.e(TAG, "Broken text."); |
| return null; |
| } |
| int compressionType = data[pos] & 0xff; |
| int mode = data[pos + 1] & 0xff; |
| int numBytes = data[pos + 2] & 0xff; |
| if (data.length < pos + 3 + numBytes) { |
| Log.e(TAG, "Broken text."); |
| return null; |
| } |
| byte[] bytes = Arrays.copyOfRange(data, pos + 3, pos + 3 + numBytes); |
| if (compressionType == COMPRESSION_TYPE_NO_COMPRESSION) { |
| try { |
| switch (mode) { |
| case MODE_SELECTED_UNICODE_RANGE_1: |
| return new String(bytes, "ISO-8859-1"); |
| case MODE_SCSU: |
| return UnicodeDecompressor.decompress(bytes); |
| case MODE_UTF16: |
| return new String(bytes, "UTF-16"); |
| } |
| } catch (UnsupportedEncodingException e) { |
| Log.e(TAG, "Unsupported text format.", e); |
| } |
| } |
| pos += 3 + numBytes; |
| } |
| } |
| return null; |
| } |
| |
| private static String extractTextFromDvb(byte[] data, int pos, int length) { |
| // For details of DVB character set selection, see DVB Document A038 Annex A. |
| if (data.length < pos + length) { |
| return null; |
| } |
| try { |
| String charsetPrefix = "ISO-8859-"; |
| switch (data[0]) { |
| case 0x01: |
| case 0x02: |
| case 0x03: |
| case 0x04: |
| case 0x05: |
| case 0x06: |
| case 0x07: |
| case 0x09: |
| case 0x0A: |
| case 0x0B: |
| String charset = charsetPrefix + String.valueOf(data[0] & 0xff + 4); |
| return new String(data, pos, length, charset); |
| case 0x10: |
| if (length < 3) { |
| Log.e(TAG, "Broken DVB text"); |
| return null; |
| } |
| int codeTable = data[pos + 2] & 0xff; |
| if (data[pos + 1] == 0 && codeTable > 0 && codeTable < 15) { |
| return new String( |
| data, pos, length, charsetPrefix + String.valueOf(codeTable)); |
| } else { |
| return new String(data, pos, length, "ISO-8859-1"); |
| } |
| case 0x11: |
| case 0x14: |
| case 0x15: |
| return new String(data, pos, length, "UTF-16BE"); |
| case 0x12: |
| return new String(data, pos, length, "EUC-KR"); |
| case 0x13: |
| return new String(data, pos, length, "GB2312"); |
| default: |
| return new String(data, pos, length, "ISO-8859-1"); |
| } |
| } catch (UnsupportedEncodingException e) { |
| Log.e(TAG, "Unsupported text format.", e); |
| } |
| return new String(data, pos, length); |
| } |
| |
| private static boolean checkSanity(byte[] data) { |
| if (data.length <= 1) { |
| return false; |
| } |
| boolean hasCRC = (data[1] & 0x80) != 0; // section_syntax_indicator |
| if (hasCRC) { |
| int crc = 0xffffffff; |
| for(byte b : data) { |
| int index = ((crc >> 24) ^ (b & 0xff)) & 0xff; |
| crc = CRC_TABLE[index] ^ (crc << 8); |
| } |
| if(crc != 0){ |
| return false; |
| } |
| } |
| return true; |
| } |
| } |
