public List <VideoInfo> GetVideoInfo(string VideoRootPath)
{
List <VideoInfo> VideoInfoList = new List <VideoInfo>();
JsonAnalysis jal = new JsonAnalysis();
ModeEntry me = null;
if (VideoRootPath != null)
{
string[] path = Directory.GetDirectories(VideoRootPath);
for (int i = 0; i < path.Length; i++)
{
VideoInfo temp = new VideoInfo();
temp.videoPath = path[i] + @"\lua.flv.bili2api.80";
me = jal.GetJsonConfig(path[i]);
temp.videoName = me.page_data.part;
VideoInfoList.Add(temp);
}
}
else
{
MessageBox.Show("视频路径为空，请先选择", "提示");
}
log(VideoInfoList);
return(VideoInfoList);
}
void Start()
{
foreach (ModeData modeData in ModeManager.instance.modes)
{
ModeEntry modeEntry = Instantiate(this.modeEntry) as ModeEntry;
modeEntry.SetPanel(panel);
modeEntry.SetMode(modeData);
modeEntry.transform.SetParent(modeHolder.transform);
}
}
void Start()
{
foreach (ModeManager.ModeData mode in ModeManager.instance.modes)
{
GameObject entryGameObject = Instantiate(modeEntryPrefab) as GameObject;
ModeEntry entry = entryGameObject.GetComponent <ModeEntry>();
entry.SetMode(mode);
entry.transform.SetParent(transform);
}
}
public ModeEntry GetJsonConfig(string videoPath)
{
ModeEntry me = new ModeEntry();
try {
string entryPath = videoPath + @"\entry.json";
string js = File.ReadAllText(entryPath);
me = JsonMapper.ToObject <ModeEntry>(js);
} catch (Exception ex) {
MessageBox.Show(ex.Message);
}
return(me);
}
internal static void ScanModes()
{
var modesData = new Dictionary <string, object> {
[k_DefaultModeId] = new Dictionary <string, object> {
[k_LabelSectionName] = "Default"
}
};
var builtinModeFile = Path.Combine(EditorApplication.applicationContentsPath, "Resources/default.mode");
FillModeData(builtinModeFile, modesData);
var modeDescriptors = AssetDatabase.EnumerateAllAssets(new SearchFilter
{
searchArea = SearchFilter.SearchArea.InPackagesOnly,
classNames = new[] { nameof(ModeDescriptor) },
skipHidden = true,
showAllHits = true
});
while (modeDescriptors.MoveNext())
{
var md = modeDescriptors.Current.pptrValue as ModeDescriptor;
if (md == null)
{
continue;
}
FillModeData(md.path, modesData);
}
modes = new ModeEntry[modesData.Keys.Count];
modes[0] = CreateEntry(k_DefaultModeId, (JSONObject)modesData[k_DefaultModeId]);
var modeIndex = 1;
hasSwitchableModes = false;
foreach (var modeId in modesData.Keys)
{
if (modeId == k_DefaultModeId)
{
continue;
}
var modeFields = (JSONObject)modesData[modeId];
modes[modeIndex] = CreateEntry(modeId, modeFields);
hasSwitchableModes |= !JsonUtils.JsonReadBoolean(modeFields, "builtin");
modeIndex++;
}
}
static void Build(string input, string output, int version)
{
// Load source file in memory and verify
List <string[]> valueList = new List <string[]>();
int lineNumber = 0;
Regex lineFormat = new Regex(@"^(\$?%{0,2})((?:/[^\\/:\*\?""<>|]+)+)\s(?i)([VGUPLRA]+)$");
using (FileStream txtStream = new FileStream(input, FileMode.Open, FileAccess.Read))
using (TextReader txt = new StreamReader(txtStream))
{
while (txt.Peek() >= 0)
{
lineNumber++;
string line = txt.ReadLine().Trim();
if (line != "")
{
Match validation = lineFormat.Match(line);
if (validation.Success)
{
string[] result = new string[3]
{
validation.Groups[1].Value,
validation.Groups[2].Value,
validation.Groups[3].Value
};
valueList.Add(result);
}
else
{
throw new InvalidDataException(String.Format("Invalid data in file {0} at line {1}.", input, lineNumber));
}
}
}
}
string[][] values = valueList.ToArray();
int moduleCount = valueList.Count;
Console.WriteLine(String.Format("File contains {0} modules.", moduleCount));
Console.Write(String.Format("Building v{0} pspbtcnf binary...", GetVersion(version)));
// Build modules & modulelist
string moduleList = "";
ModuleEntry[] modules = new ModuleEntry[moduleCount];
for (int i = 0; i < moduleCount; i++)
{
// Modulelist & offset
modules[i].nameOffset = (uint)moduleList.Length;
moduleList += values[i][1] + '\0';
// Loadmode flags
bool dollar = false;
byte percent = 0;
for (int a = 0; a < values[i][0].Length; a++)
{
if (values[i][0][a] == '$')
{
dollar = true;
}
else if (values[i][0][a] == '%')
{
percent++;
}
}
switch (percent)
{
case 2:
modules[i].loadmode = (ushort)((dollar ? load_flags.DollarSign : 0) | load_flags.TwoPercent);
break;
case 1:
modules[i].loadmode = (ushort)((dollar ? load_flags.DollarSign : 0) | load_flags.OnePercent);
break;
case 0:
modules[i].loadmode = (ushort)((dollar ? load_flags.DollarSign : 0) | load_flags.NoPercent);
break;
}
// Section flags
section_flags flags = new section_flags();
for (int a = 0; a < values[i][2].Length; a++)
{
switch (values[i][2][a])
{
case 'v':
case 'V':
flags |= section_flags.VSH;
break;
case 'g':
case 'G':
flags |= section_flags.Game;
break;
case 'u':
case 'U':
flags |= section_flags.Updater;
break;
case 'p':
case 'P':
flags |= section_flags.Pops;
break;
case 'l':
case 'L':
flags |= section_flags.License;
break;
case 'r':
case 'R':
flags |= section_flags.Reserved;
break;
case 'a':
case 'A':
flags |= section_flags.App;
break;
}
}
modules[i].flags = (ushort)flags;
// Fill in unknown/unused info
modules[i].hash = new byte[0x10];
modules[i].reserved1 = 0;
modules[i].reserved2 = 0;
}
// Build mode entries
ModeEntry[] modes = new ModeEntry[5];
modes[0].searchMax = (ushort)moduleCount;
modes[0].modeFlag = (int)section_flags.VSH;
modes[0].mode2 = 2;
modes[0].reserved = new int[5];
modes[0].searchStart = 0;
modes[1].searchMax = (ushort)moduleCount;
modes[1].modeFlag = (int)section_flags.Game;
modes[1].mode2 = 1;
modes[1].reserved = new int[5];
modes[1].searchStart = 0;
modes[2].searchMax = (ushort)moduleCount;
modes[2].modeFlag = (int)section_flags.Updater;
modes[2].mode2 = 3;
modes[2].reserved = new int[5];
modes[2].searchStart = 0;
modes[3].searchMax = (ushort)moduleCount;
modes[3].modeFlag = (int)section_flags.Pops;
modes[3].mode2 = 4;
modes[3].reserved = new int[5];
modes[3].searchStart = 0;
modes[4].searchMax = (ushort)moduleCount;
modes[4].modeFlag = (int)section_flags.App;
modes[4].mode2 = 7;
modes[4].reserved = new int[5];
modes[4].searchStart = 0;
int modeCount = modes.Length;
// Build header
BtcnfHeader head = new BtcnfHeader();
head.modeStartOffset = headerSize;
head.modeCount = modeCount;
head.moduleStartOffset = head.modeStartOffset + modeEntrySize * modeCount;
head.moduleCount = (uint)moduleCount;
head.moduleNameStartOffset = head.moduleStartOffset + moduleEntrySize * moduleCount;
head.moduleNameEndOffset = head.moduleNameStartOffset + moduleList.Length;
head.unknown1 = unknown1;
head.unknown2 = unknown2;
head.unknown3 = unknown3;
head.unknown4 = unknown4;
head.version = version;
head.signature = sigValid;
// Write output
using (FileStream bin = new FileStream(output, FileMode.Create, FileAccess.Write))
{
byte[] headerBytes = StructureToByteArray <BtcnfHeader>(head, headerSize);
bin.Write(headerBytes, 0, headerBytes.Length);
for (int i = 0; i < modes.Length; i++)
{
byte[] modeBytes = StructureToByteArray <ModeEntry>(modes[i], modeEntrySize);
bin.Seek(head.modeStartOffset + i * modeEntrySize, SeekOrigin.Begin);
bin.Write(modeBytes, 0, modeBytes.Length);
}
for (int i = 0; i < moduleCount; i++)
{
byte[] moduleBytes = StructureToByteArray <ModuleEntry>(modules[i], moduleEntrySize);
bin.Seek(head.moduleStartOffset + i * moduleEntrySize, SeekOrigin.Begin);
bin.Write(moduleBytes, 0, moduleBytes.Length);
}
byte[] moduleListBytes = ASCIIEncoding.UTF8.GetBytes(moduleList);
bin.Seek(head.moduleNameStartOffset, SeekOrigin.Begin);
bin.Write(moduleListBytes, 0, moduleListBytes.Length);
bin.Flush();
bin.Close();
}
Console.WriteLine("Done!");
Console.WriteLine(String.Format("Output saved to {0}", output));
}
static void Extract(string input, string output)
{
string[] lines;
using (FileStream bin = new FileStream(input, FileMode.Open, FileAccess.Read))
{
// Read header
BtcnfHeader head;
try
{
//bin.Seek(0, SeekOrigin.Begin);
head = ByteArrayToStructure <BtcnfHeader>(ReadByteArray(bin, 0, headerSize));
}
catch (Exception ex)
{
throw new InvalidDataException("Unable to access or invalid input file.", ex);
}
// Check signature
switch (head.signature)
{
case sigValid:
Console.WriteLine(String.Format("v{0} pspbtcnf binary", GetVersion(head.version)));
break;
case sigEnc:
throw new InvalidDataException("Input file is encrypted.");
case sigOld:
throw new InvalidDataException("Input file is in an older format.");
default:
throw new InvalidDataException(String.Format("Input file has an unknown signature 0x{0:X8} or is not a valid pspbtcnf file.", head.signature));
}
// Mode entries
//bin.BaseStream.Seek(head.modeStartOffset, 0);
ModeEntry[] modes = new ModeEntry[head.modeCount];
for (int i = 0; i < head.modeCount; i++)
{
modes[i] = ByteArrayToStructure <ModeEntry>(ReadByteArray(bin, head.modeStartOffset * i, modeEntrySize));
}
// Grab module names
//bin.BaseStream.Seek(head.moduleNameStartOffset, 0);
int moduleNameLength = head.moduleNameEndOffset - head.moduleNameStartOffset;
byte[] moduleNameData = ReadByteArray(bin, head.moduleNameStartOffset, moduleNameLength);
Dictionary <uint, string> moduleNames = OffsetSplit(ASCIIEncoding.UTF8.GetString(moduleNameData));
// Fix invalid header
if (moduleNames.Count != head.moduleCount)
{
Console.WriteLine(String.Format("Header lists {0} modules, file contains {1} modules. Fixed.", head.moduleCount, moduleNames.Count));
head.moduleCount = (uint)moduleNames.Count;
}
else
{
Console.WriteLine(String.Format("File contains {0} modules.", head.moduleCount));
}
Console.Write("Processing module list...");
// Dump modules
lines = new string[head.moduleCount];
for (int i = 0; i < head.moduleCount; i++)
{
//bin.BaseStream.Seek(head.moduleStartOffset + moduleEntrySize * i, SeekOrigin.Begin);
ModuleEntry module = ByteArrayToStructure <ModuleEntry>(ReadByteArray(bin, head.moduleStartOffset + moduleEntrySize * i, moduleEntrySize));
lines[i] = "";
if (((load_flags)module.loadmode & load_flags.DollarSign) == load_flags.DollarSign)
{
lines[i] += "$";
}
if (((load_flags)module.loadmode & load_flags.OnePercent) == load_flags.OnePercent)
{
lines[i] += "%";
}
if (((load_flags)module.loadmode & load_flags.TwoPercent) == load_flags.TwoPercent)
{
lines[i] += "%%";
}
lines[i] += moduleNames[module.nameOffset] + " ";
if (((section_flags)module.flags & section_flags.VSH) == section_flags.VSH)
{
lines[i] += "V";
}
if (((section_flags)module.flags & section_flags.Game) == section_flags.Game)
{
lines[i] += "G";
}
if (((section_flags)module.flags & section_flags.Updater) == section_flags.Updater)
{
lines[i] += "U";
}
if (((section_flags)module.flags & section_flags.Pops) == section_flags.Pops)
{
lines[i] += "P";
}
if (((section_flags)module.flags & section_flags.License) == section_flags.License)
{
lines[i] += "L";
}
if (((section_flags)module.flags & section_flags.Reserved) == section_flags.Reserved)
{
lines[i] += "R";
}
if (((section_flags)module.flags & section_flags.App) == section_flags.App)
{
lines[i] += "A";
}
}
bin.Close();
}
// Write to output
using (FileStream txtStream = new FileStream(output, FileMode.Create, FileAccess.Write))
using (TextWriter txt = new StreamWriter(txtStream))
{
for (int i = 0; i < lines.Length; i++)
{
txt.WriteLine(lines[i]);
}
txt.Flush();
txt.Close();
}
Console.WriteLine("Done!");
Console.WriteLine(String.Format("Output saved to {0}", output));
}
