void TaskMethod(object toRun)
{
InfoProviderBase provider = toRun as InfoProviderBase;
provider.DoUpdateInfo(currentDecision);//currentDecision.PlayerId, currentDecision.Cache, cacheTracker, selectedTaskTree.ActualKey);
if (selectedTaskTree.dependents.ContainsKey(provider.ProviderType))
{
foreach (var dependent in selectedTaskTree.dependents[provider.ProviderType])
{
lock (dependent.PrerequesitesLocker)
{
if (dependent.PrerequesitesLeft > 0)
{
dependent.PrerequesitesLeft--;
if (dependent.PrerequesitesLeft == 0)
{
if (ConcurrencyMode.Concurrency == ConcurrencyMode.ConcurencyModel.MultiCore)
{
providerTasks[dependent.ProviderType].Start();
}
else
{
providerActions[dependent.ProviderType]();
}
}
}
}
}
}
}
public static string CreateTxtLog(string path, InfoProviderBase p)
{
XmlDocument xmlDoc = CreateNewAVDumpLog(p);
Func <string, string> formatDuration = (ldStr) => {
var duration = TimeSpan.FromSeconds(double.Parse(ldStr)).ToString();
return(duration.IndexOf(".") < 0 ? duration : duration.Substring(0, duration.IndexOf('.')));
};
string log = "File: " + path + Environment.NewLine;
foreach (XmlElement node in xmlDoc["Creq"]["File"]["General"])
{
log += " " + node.Name + ": " + (node.Name.Equals("Duration") ? formatDuration(node.InnerText) : node.InnerText) + Environment.NewLine;
}
if (xmlDoc["Creq"]["File"]["Hashes"].HasChildNodes)
{
log += " #Hashes" + Environment.NewLine;
}
foreach (XmlElement streamsNode in xmlDoc["Creq"]["File"]["Hashes"])
{
log += " " + streamsNode.Name + ": " + streamsNode.InnerText + Environment.NewLine;
}
foreach (XmlElement streamsNode in xmlDoc["Creq"]["File"]["VideoStreams"])
{
log += " #Videostream" + Environment.NewLine;
foreach (XmlElement node in streamsNode)
{
log += " " + node.Name + ": " + (node.Name.Equals("Duration") ? formatDuration(node.InnerText) : node.InnerText) + Environment.NewLine;
}
}
foreach (XmlElement streamsNode in xmlDoc["Creq"]["File"]["AudioStreams"])
{
log += " #Audiostream" + Environment.NewLine;
foreach (XmlElement node in streamsNode)
{
log += " " + node.Name + ": " + (node.Name.Equals("Duration") ? formatDuration(node.InnerText) : node.InnerText) + Environment.NewLine;
}
}
foreach (XmlElement streamsNode in xmlDoc["Creq"]["File"]["SubtitleStreams"])
{
log += " #Subtitlestream" + Environment.NewLine;
foreach (XmlElement node in streamsNode)
{
log += " " + node.Name + ": " + (node.Name.Equals("Duration") ? formatDuration(node.InnerText) : node.InnerText) + Environment.NewLine;
}
}
return(log);
}
public static string CreateHashLog(string path, InfoProviderBase p)
{
XmlDocument xmlDoc = CreateNewAVDumpLog(p);
string log = "";
if (xmlDoc["Creq"]["File"]["Hashes"].HasChildNodes)
{
log = " #Hashes" + Environment.NewLine;
}
foreach (XmlElement streamsNode in xmlDoc["Creq"]["File"]["Hashes"])
{
log += " " + streamsNode.Name + ": " + streamsNode.InnerText + Environment.NewLine;
}
return(log);
}
public static XmlDocument CreateNewAVDumpLog(InfoProviderBase provider)
{
XmlDocument xmlDoc = new XmlDocument();;
Func <string, string, string, string, XmlNode> createNode = (name, value, unit, p) => {
var n = xmlDoc.CreateElement(name);
if (!string.IsNullOrEmpty(unit))
{
n.Attributes.Append(xmlDoc.CreateAttribute("u")).Value = unit;
}
//if(!string.IsNullOrEmpty(p)) n.Attributes.Append(xmlDoc.CreateAttribute("p")).Value = p;
n.AppendChild(xmlDoc.CreateTextNode(value));
return(n);
};
Func <InfoProviderBase, string> getName = (p) => { return(p.ToString().Substring(p.ToString().LastIndexOf('.') + 1)); };
var aCreqNode = xmlDoc.AppendChild(xmlDoc.CreateElement("Creq"));
var fileNode = aCreqNode.AppendChild(xmlDoc.CreateElement("File"));
var hashNode = fileNode.AppendChild(xmlDoc.CreateElement("Hashes"));
var generalNode = fileNode.AppendChild(xmlDoc.CreateElement("General"));
var videoNode = fileNode.AppendChild(xmlDoc.CreateElement("VideoStreams"));
var audioNode = fileNode.AppendChild(xmlDoc.CreateElement("AudioStreams"));
var subtitleNode = fileNode.AppendChild(xmlDoc.CreateElement("SubtitleStreams"));
var chaptersNode = fileNode.AppendChild(xmlDoc.CreateElement("Chapters"));
XmlNode node;
var lookUp = new Dictionary <KeyValuePair <StreamType, int>, XmlNode>();
foreach (var entry in provider)
{
var pair = new KeyValuePair <StreamType, int>(entry.Key.Type, entry.Key.Index);
if (!lookUp.TryGetValue(pair, out node))
{
switch (pair.Key)
{
case StreamType.General: node = generalNode; break;
case StreamType.Video: lookUp[pair] = node = xmlDoc.CreateElement("VideoStream"); videoNode.AppendChild(node); break;
case StreamType.Audio: lookUp[pair] = node = xmlDoc.CreateElement("AudioStream"); audioNode.AppendChild(node); break;
case StreamType.Text: lookUp[pair] = node = xmlDoc.CreateElement("SubtitleStream"); subtitleNode.AppendChild(node); break;
case StreamType.Hash: lookUp[pair] = node = hashNode; break;
case StreamType.Chapter: break;
default: break;
}
}
if (entry.Key.Type == StreamType.Hash)
{
node.AppendChild(createNode(entry.Unit, entry.Value, null, null));
}
else
{
node.AppendChild(createNode(entry.Key.Entry.ToString(), entry.Value, entry.Unit, getName(entry.Provider)));
}
}
var comp = (CompositeInfoProvider)provider;
if (comp.GetProvider <MatroskaProvider>() != null)
{
var mkvProvider = comp.GetProvider <MatroskaProvider>();
var matroskaFile = mkvProvider.MFI;
if (matroskaFile.Segment.SegmentInfo.PreviousUId != null)
{
generalNode.AppendChild(createNode("PreviousUId", new Guid(matroskaFile.Segment.SegmentInfo.PreviousUId).ToString(), null, getName(mkvProvider)));
}
if (matroskaFile.Segment.SegmentInfo.NextUId != null)
{
generalNode.AppendChild(createNode("NextUId", new Guid(matroskaFile.Segment.SegmentInfo.NextUId).ToString(), null, getName(mkvProvider)));
}
if (matroskaFile.Segment.SegmentInfo.PreviousFilename != null)
{
generalNode.AppendChild(createNode("PreviousFilename", matroskaFile.Segment.SegmentInfo.PreviousFilename, null, getName(mkvProvider)));
}
if (matroskaFile.Segment.SegmentInfo.NextFilename != null)
{
generalNode.AppendChild(createNode("NextFilename", matroskaFile.Segment.SegmentInfo.NextFilename, null, getName(mkvProvider)));
}
if (matroskaFile.Segment.SegmentInfo.SegmentUId != null)
{
generalNode.AppendChild(createNode("SegmentUId", new Guid(matroskaFile.Segment.SegmentInfo.SegmentUId).ToString(), null, getName(mkvProvider)));
}
if (matroskaFile.Segment.Chapters != null)
{
CreateEBMLTree(xmlDoc, chaptersNode, matroskaFile.Segment.Chapters);
}
}
else
{
try { CreateChaptersMIL(xmlDoc, chaptersNode, comp.GetProvider <MediaInfoProvider>().MIL); } catch (Exception) { }
}
return(xmlDoc);
}
public static XmlDocument CreateOldAVDumpLog(string path, InfoProviderBase p)
{
IMediaInfo mediaInfo;
MatroskaFile matroskaFileInfo;
XmlDocument xmlDoc = new XmlDocument();
XmlNode node, subNode;
int streamCount;
string milInfo;
node = xmlDoc.AppendChild(xmlDoc.CreateElement("file"));
AppendLeaf(xmlDoc, node, "size", (new FileInfo(path)).Length.ToString(), null);
//if(blockConsumers != null) {
// foreach(IBlockConsumer blockConsumer in blockConsumers) {
// if(blockConsumer is HashCalculator) {
// HashCalculator hashExecute = (HashCalculator)blockConsumer;
// BaseOption baseOption = (hashExecute.HashObj is TreeHash || hashExecute.HashObj is TigerThex ? BaseOption.Base32 : BaseOption.Heximal) | BaseOption.Pad | BaseOption.Reverse;
// AppendLeaf(xmlDoc, node, hashExecute.Name.ToLower(), BaseConverter.ToString(hashExecute.HashObj.Hash, baseOption).ToLower(), null);
// if(hashExecute.HashObj is Ed2k) {
// Ed2k ed2k = (Ed2k)hashExecute.HashObj;
// if(!ed2k.BlueIsRed) {
// baseOption = BaseOption.Heximal | BaseOption.Pad | BaseOption.Reverse;
// AppendLeaf(xmlDoc, node, hashExecute.Name.ToLower() + "_alt", BaseConverter.ToString(ed2k.RedHash, baseOption).ToLower(), null);
// }
// }
// } else if(blockConsumer is MatroskaParser) {
// matroskaFileInfo = (MatroskaParser)blockConsumer;
// }
// }
//}
mediaInfo = CreateMediaInfoInstance();
mediaInfo.Open(path);
node = node.AppendChild(xmlDoc.CreateElement("avmf"));
milInfo = mediaInfo.Get(eStreamType.General, 0, "Duration");
if (!String.IsNullOrEmpty(milInfo))
{
AppendLeaf(xmlDoc, node, "duration", (double.Parse(milInfo, CultureInfo.InvariantCulture) / 1000d).ToString(CultureInfo.InvariantCulture), null);
AppendLeaf(xmlDoc, node, "duration2", TimeSpan.FromSeconds(((long)double.Parse(milInfo, CultureInfo.InvariantCulture) / 1000)).ToString(), null);
}
AppendLeaf(xmlDoc, node, "extension", mediaInfo.Get(eStreamType.General, 0, "FileExtension"), null);
//AppendLeaf(xmlDoc, node, "date", mi.Get(StreamKind.General, 0, ""));
AppendLeaf(xmlDoc, node, "chapters", mediaInfo.Get(eStreamType.General, 0, "ChaptersCount"), null);
AppendLeaf(xmlDoc, node, "app", mediaInfo.Get(eStreamType.General, 0, "Encoded_Application"), null);
AppendLeaf(xmlDoc, node, "lib", mediaInfo.Get(eStreamType.General, 0, "Encoded_Library"), null);
streamCount = mediaInfo.Count_Get(eStreamType.Video);
for (int i = 0; i < streamCount; i++)
{
subNode = node.AppendChild(xmlDoc.CreateElement("video"));
AppendLeaf(xmlDoc, subNode, "title", mediaInfo.Get(eStreamType.Video, i, "Title"), null);
var asdf = mediaInfo.Get(eStreamType.Video, i, "StreamSize");
if (!String.IsNullOrEmpty(asdf))
{
asdf = "";
}
AppendLeaf(xmlDoc, subNode, "size", mediaInfo.Get(eStreamType.Video, i, "StreamSize"), null);
milInfo = mediaInfo.Get(eStreamType.Video, i, "Duration");
if (!String.IsNullOrEmpty(milInfo))
{
AppendLeaf(xmlDoc, subNode, "duration", (double.Parse(milInfo, CultureInfo.InvariantCulture) / 1000d).ToString(CultureInfo.InvariantCulture), null);
AppendLeaf(xmlDoc, subNode, "duration2", TimeSpan.FromSeconds(((long)double.Parse(milInfo, CultureInfo.InvariantCulture) / 1000)).ToString(), null);
}
//AppendLeaf(xmlDoc, subNode, "identifier", mi.Get(StreamKind.Video, i, ""));
milInfo = mediaInfo.Get(eStreamType.Video, i, "BitRate");
if (!String.IsNullOrEmpty(milInfo))
{
AppendLeaf(xmlDoc, subNode, "bitrate2", ((long)double.Parse(milInfo, CultureInfo.InvariantCulture) / 1000).ToString(), new String[, ] {
{ "unit", "kbit/s" }
});
}
AppendLeaf(xmlDoc, subNode, "bitrate", mediaInfo.Get(eStreamType.Video, i, "BitRate"), null);
AppendLeaf(xmlDoc, subNode, "fourcc", mediaInfo.Get(eStreamType.Video, i, "CodecID"), null); //Codec/CC
AppendLeaf(xmlDoc, subNode, "fps", mediaInfo.Get(eStreamType.Video, i, "FrameRate"), null);
AppendLeaf(xmlDoc, subNode, "encoder", mediaInfo.Get(eStreamType.Video, i, "Encoded_Library"), null);
AppendLeaf(xmlDoc, subNode, "setting", mediaInfo.Get(eStreamType.Video, i, "Encoded_Library_Settings"), null);
//AppendLeaf(xmlDoc, subNode, "private", mi.Get(StreamKind.Video, i, ""));
AppendLeaf(xmlDoc, subNode, "sample_count", mediaInfo.Get(eStreamType.Video, i, "FrameCount"), null);
AppendLeaf(xmlDoc, subNode, "chroma", mediaInfo.Get(eStreamType.Video, i, "Colorimetry"), null);
AppendLeaf(xmlDoc, subNode, "structure", mediaInfo.Get(eStreamType.Video, i, "Interlacement"), null);
AppendLeaf(xmlDoc, subNode, "res_p", null, new String[, ] {
{ "width", mediaInfo.Get(eStreamType.Video, i, "Width") },
{ "height", mediaInfo.Get(eStreamType.Video, i, "Height") }
});
//AppendLeaf(xmlDoc, subNode, "dar", mediaInfo.Get(eStreamKind.Video, i, "DisplayAspectRatio"), null);
string res_d = mediaInfo.Get(eStreamType.Video, i, "DisplayAspectRatio/String");
if (res_d.Contains(":"))
{
AppendLeaf(xmlDoc, subNode, "dar", null, new String[, ] {
{ "width", res_d.Split(':')[0].ToString() }, { "height", res_d.Split(':')[1].ToString() }
});
}
}
streamCount = mediaInfo.Count_Get(eStreamType.Audio);
for (int i = 0; i < streamCount; i++)
{
subNode = node.AppendChild(xmlDoc.CreateElement("audio"));
milInfo = mediaInfo.Get(eStreamType.Audio, i, "Duration");
if (!String.IsNullOrEmpty(milInfo))
{
AppendLeaf(xmlDoc, subNode, "duration", (double.Parse(milInfo, CultureInfo.InvariantCulture) / 1000d).ToString(CultureInfo.InvariantCulture), null);
AppendLeaf(xmlDoc, subNode, "duration2", TimeSpan.FromSeconds(((long)double.Parse(milInfo, CultureInfo.InvariantCulture) / 1000)).ToString(), null);
}
AppendLeaf(xmlDoc, subNode, "size", mediaInfo.Get(eStreamType.Audio, i, "StreamSize"), null);
AppendLeaf(xmlDoc, subNode, "title", mediaInfo.Get(eStreamType.Audio, i, "Title"), null);
AppendLeaf(xmlDoc, subNode, "bitrate", mediaInfo.Get(eStreamType.Audio, i, "BitRate"), null);
milInfo = mediaInfo.Get(eStreamType.Audio, i, "BitRate");
if (!String.IsNullOrEmpty(milInfo))
{
AppendLeaf(xmlDoc, subNode, "bitrate2", ((long)double.Parse(milInfo, CultureInfo.InvariantCulture) / 1000).ToString(), new String[, ] {
{ "unit", "kbit/s" }
});
}
AppendLeaf(xmlDoc, subNode, "language", mediaInfo.Get(eStreamType.Audio, i, "Language"), null);
//AppendLeaf(xmlDoc, subNode, "identifier", mi.Get(StreamKind.Audio, i, ""));
AppendLeaf(xmlDoc, subNode, "twocc", mediaInfo.Get(eStreamType.Audio, i, "Codec"), null);
AppendLeaf(xmlDoc, subNode, "channels", mediaInfo.Get(eStreamType.Audio, i, "Channel(s)"), null);
AppendLeaf(xmlDoc, subNode, "sampling_rate", mediaInfo.Get(eStreamType.Audio, i, "SamplingRate"), null);
AppendLeaf(xmlDoc, subNode, "mode", mediaInfo.Get(eStreamType.Audio, i, "BitRate_Mode"), null);
AppendLeaf(xmlDoc, subNode, "sample_count", mediaInfo.Get(eStreamType.Audio, i, "SamplingCount"), null);
}
streamCount = mediaInfo.Count_Get(eStreamType.Text);
for (int i = 0; i < streamCount; i++)
{
subNode = node.AppendChild(xmlDoc.CreateElement("subtitles"));
//AppendLeaf(xmlDoc, subNode, "size", mi.Get(StreamKind.Text, i, ""));
AppendLeaf(xmlDoc, subNode, "title", mediaInfo.Get(eStreamType.Text, i, "Title"), null);
AppendLeaf(xmlDoc, subNode, "language", mediaInfo.Get(eStreamType.Text, i, "Language"), null);
AppendLeaf(xmlDoc, subNode, "identifier", mediaInfo.Get(eStreamType.Text, i, "Codec"), null);
}
mediaInfo.Close();
return(xmlDoc);
}
public static XmlDocument CreateAVDumpLog(InfoProviderBase p)
{
XmlDocument xmlDoc = new XmlDocument();
Func <InfoProviderBase, string> getName = (provider) => {
string name;
if (provider is MatroskaProvider)
{
name = "mkv";
}
else if (provider is MediaInfoProvider)
{
name = "mil";
}
else if (provider is OgmOggProvider)
{
name = "ogm";
}
else if (provider is HashInfoProvider)
{
name = "hash";
}
else if (provider is FileExtensionProvider)
{
name = "ext";
}
else
{
name = "";
}
return(name);
};
Func <string, string, string, XmlNode> createNode = (name, value, pName) => {
var n = xmlDoc.CreateElement(name);
if (value != null)
{
n.AppendChild(xmlDoc.CreateTextNode(value));
}
//if(!string.IsNullOrEmpty(pName)) n.Attributes.Append(xmlDoc.CreateAttribute("p")).Value = pName;
return(n);
};
Action <XmlNode, string, string> addAttribute = (n, name, value) => { n.Attributes.Append(xmlDoc.CreateAttribute(name)).Value = value; };
Func <StreamType, TrackEntrySection.Types> convertEnum = t => t == StreamType.Audio ? TrackEntrySection.Types.Audio : (t == StreamType.Video ? TrackEntrySection.Types.Video : (t == StreamType.Text ? TrackEntrySection.Types.Subtitle : 0));
var toAcreqName = new Dictionary <EntryKey, string>();
toAcreqName[EntryKey.MuxingApp] = "app";
toAcreqName[EntryKey.EncodeLibrary] = "encoder";
toAcreqName[EntryKey.WritingApp] = "lib";
toAcreqName[EntryKey.CodecId] = "identifier";
toAcreqName[EntryKey.CodecIdAlt] = "identifier2";
toAcreqName[EntryKey.FrameRate] = "fps";
toAcreqName[EntryKey.FrameCount] = "sample_count";
toAcreqName[EntryKey.SampleCount] = "sample_count";
toAcreqName[EntryKey.EncodeSettings] = "settings";
toAcreqName[EntryKey.ChannelCount] = "channels";
toAcreqName[EntryKey.SamplingRate] = "sampling_rate";
toAcreqName[EntryKey.FileExtension] = "file_extension";
toAcreqName[EntryKey.Extension] = "extension";
toAcreqName[EntryKey.CodecName] = "codec_name";
toAcreqName[EntryKey.Overhead] = "extra_size";
toAcreqName[EntryKey.BitrateMode] = "mode";
toAcreqName[EntryKey.DAR] = "ar";
toAcreqName[EntryKey.VFR] = null;
toAcreqName[EntryKey.TrackNumber] = null;
toAcreqName[EntryKey.MaxFrameRate] = null;
toAcreqName[EntryKey.MinFrameRate] = null;
var fileNode = xmlDoc.AppendChild(xmlDoc.CreateElement("file"));
var avmfNode = xmlDoc.CreateElement("avmf");
var lookUp = new Dictionary <KeyValuePair <StreamType, int>, XmlNode>();
XmlNode node, fpsNode = null;
CompositeInfoProvider comp = (CompositeInfoProvider)p;
foreach (var entry in p)
{
var pair = new KeyValuePair <StreamType, int>(entry.Key.Type, entry.Key.Index);
if (pair.Key == StreamType.Text && (entry.Key.Entry == EntryKey.Bitrate || entry.Key.Entry == EntryKey.Duration || entry.Key.Entry == EntryKey.BitrateMode))
{
continue;
}
if (!lookUp.TryGetValue(pair, out node))
{
switch (pair.Key)
{
case StreamType.General: node = entry.Key.Entry == EntryKey.Size ? fileNode : avmfNode; break;
case StreamType.Video:
lookUp[pair] = node = xmlDoc.CreateElement("video"); avmfNode.AppendChild(node);
if (comp.GetProvider <MatroskaProvider>() != null)
{
var matroskaFile = comp.GetProvider <MatroskaProvider>().MFI;
var subNode = node.AppendChild(createNode("res_d", null, "mkv"));
addAttribute(subNode, "width", matroskaFile.Segment.Tracks[TrackEntrySection.Types.Video, entry.Key.Index].Video.DisplayWidth.ToString());
addAttribute(subNode, "height", matroskaFile.Segment.Tracks[TrackEntrySection.Types.Video, entry.Key.Index].Video.DisplayHeight.ToString());
}
break;
case StreamType.Audio: lookUp[pair] = node = xmlDoc.CreateElement("audio"); avmfNode.AppendChild(node); break;
case StreamType.Text: lookUp[pair] = node = xmlDoc.CreateElement("subtitles"); avmfNode.AppendChild(node); break;
case StreamType.Unkown: lookUp[pair] = node = xmlDoc.CreateElement("unkownstream"); avmfNode.AppendChild(node); break;
case StreamType.Hash: lookUp[pair] = node = fileNode; break;
case StreamType.Chapter: break;
default: break;
}
if (comp.GetProvider <MatroskaProvider>() != null)
{
var matroskaFile = comp.GetProvider <MatroskaProvider>().MFI;
if (pair.Key == StreamType.Audio || pair.Key == StreamType.Video || pair.Key == StreamType.Text)
{
if ((matroskaFile.Segment.Tracks[convertEnum(pair.Key), entry.Key.Index].TrackFlags & TrackEntrySection.Options.Default) != 0)
{
addAttribute(node, "default", "1");
}
}
}
}
string name, value;
if (!toAcreqName.TryGetValue(entry.Key.Entry, out name))
{
name = entry.Key.Entry.ToString().ToLower();
}
else if (name == null)
{
continue;
}
if (entry.Key.Entry == EntryKey.Date)
{
try {
value = Convert.ToString((int)(DateTime.ParseExact(entry.Value, "yyyy.MM.dd HH.mm.ss.ffff", CultureInfo.InvariantCulture) - new DateTime(1970, 1, 1)).TotalSeconds, 16);
} catch (Exception) { continue; }
}
else
{
value = entry.Value;
}
if (entry.Key.Entry == EntryKey.ColorBitDepth && pair.Key == StreamType.Video && ("8".Equals(entry.Value) || "0".Equals(entry.Value)))
{
continue;
}
if (entry.Key.Type == StreamType.Hash)
{
node.AppendChild(createNode(entry.Unit.ToLower(), entry.Value.ToLower(), "hash"));
}
else if (entry.Key.Entry == EntryKey.FrameRate && pair.Key == StreamType.Video)
{
var vfrInfo = p[StreamType.Video, entry.Key.Index, EntryKey.VFR];
var maxFpsInfo = p[StreamType.Video, entry.Key.Index, EntryKey.MaxFrameRate];
var minFpsInfo = p[StreamType.Video, entry.Key.Index, EntryKey.MinFrameRate];
fpsNode = node.AppendChild(createNode(name, value.Equals("") ? null : value, getName(entry.Provider)));
//fpsNode = node.AppendChild(createNode(name, null, getName(entry.Provider)));
if (vfrInfo != null)
{
addAttribute(fpsNode, "avg", vfrInfo.Value);
}
if (maxFpsInfo != null)
{
addAttribute(fpsNode, "max", maxFpsInfo.Value);
}
if (minFpsInfo != null)
{
addAttribute(fpsNode, "min", minFpsInfo.Value);
}
//if(!value.Equals("")) addAttribute(fpsNode, "entry", value);
if (comp.GetProvider <MatroskaProvider>() != null)
{
var matroskaProvider = comp.GetProvider <MatroskaProvider>();
var trackInfo = matroskaProvider.MFI.Segment.Cluster.Tracks[int.Parse(matroskaProvider[StreamType.Video, entry.Key.Index, EntryKey.TrackNumber].Value)].TrackInfo;
if (trackInfo != null && trackInfo.FPSTable != null)
{
fpsNode = node.AppendChild(createNode("fpshistogram", null, getName(matroskaProvider)));
if (trackInfo.FPSTable.Count() > 10)
{
addAttribute(fpsNode, "compressed", "k-means");
var cluster = KMeansPP(10, trackInfo.FPSTable.ToArray());
for (int i = 0; i < cluster.Length; i++)
{
var fpsEntryNode = fpsNode.AppendChild(xmlDoc.CreateElement("entry"));
addAttribute(fpsEntryNode, "fps", cluster[i][0].ToString("0.000"));
addAttribute(fpsEntryNode, "count", cluster[i][1].ToString());
}
}
else
{
foreach (var item in trackInfo.FPSTable)
{
var fpsEntryNode = fpsNode.AppendChild(xmlDoc.CreateElement("entry"));
addAttribute(fpsEntryNode, "fps", item.Key.ToString("0.000"));
addAttribute(fpsEntryNode, "count", item.Value.ToString());
}
}
}
}
}
else if ((entry.Key.Entry == EntryKey.Width || entry.Key.Entry == EntryKey.Height) && pair.Key == StreamType.Video)
{
if (node["res_p"] == null)
{
var subNode = node["res_d"] == null ? node["ar"] : node["res_d"];
if (subNode != null)
{
node.InsertBefore(xmlDoc.CreateElement("res_p"), subNode);
}
else
{
node.AppendChild(xmlDoc.CreateElement("res_p"));
}
}
node["res_p"].Attributes.Append(xmlDoc.CreateAttribute(entry.Key.Entry == EntryKey.Width ? "width" : "height")).Value = entry.Value;
}
else
{
//if(name.Equals("idenfitier") && value.Equals("-- --") || value.Equals("")) {
// return null;
//}
node.AppendChild(createNode(name, value, getName(entry.Provider)));
}
}
fileNode.AppendChild(avmfNode);
XmlNode chaptersNode;
if (comp.GetProvider <MatroskaProvider>() != null)
{
var matroskaFile = comp.GetProvider <MatroskaProvider>().MFI;
if (matroskaFile.Segment.Attachments != null)
{
fileNode.AppendChild(createNode("extra_size", matroskaFile.Segment.Attachments.SectionSize.Value.ToString(), "mkv"));
}
if (matroskaFile.Segment.SegmentInfo.PreviousUId != null)
{
avmfNode.AppendChild(createNode("previous_uid", new Guid(matroskaFile.Segment.SegmentInfo.PreviousUId).ToString(), "mkv"));
}
if (matroskaFile.Segment.SegmentInfo.NextUId != null)
{
avmfNode.AppendChild(createNode("next_uid", new Guid(matroskaFile.Segment.SegmentInfo.NextUId).ToString(), "mkv"));
}
if (matroskaFile.Segment.SegmentInfo.PreviousFilename != null)
{
avmfNode.AppendChild(createNode("previous_filename", matroskaFile.Segment.SegmentInfo.PreviousFilename, "mkv"));
}
if (matroskaFile.Segment.SegmentInfo.NextFilename != null)
{
avmfNode.AppendChild(createNode("next_filename", matroskaFile.Segment.SegmentInfo.NextFilename, "mkv"));
}
if (matroskaFile.Segment.SegmentInfo.SegmentUId != null)
{
avmfNode.AppendChild(createNode("segment_uid", new Guid(matroskaFile.Segment.SegmentInfo.SegmentUId).ToString(), "mkv"));
}
if (matroskaFile.Segment.Chapters != null)
{
foreach (var chapter in matroskaFile.Segment.Chapters)
{
chaptersNode = xmlDoc.CreateElement("Chapters");
CreateChaptersNode(xmlDoc, chaptersNode, (EditionEntrySection)chapter.Value);
if (chaptersNode.HasChildNodes)
{
avmfNode.AppendChild(chaptersNode);
}
}
}
}
else if (comp.GetProvider <MediaInfoProvider>() != null)
{
var mil = comp.GetProvider <MediaInfoProvider>().MIL;
chaptersNode = xmlDoc.CreateElement("Chapters");
try { CreateChaptersNode(xmlDoc, chaptersNode, mil); } catch (Exception) { chaptersNode.RemoveAll(); }
if (chaptersNode.HasChildNodes)
{
avmfNode.AppendChild(chaptersNode);
}
}
if (avmfNode["audio"] == null && avmfNode["video"] == null && avmfNode["duration"] != null)
{
avmfNode.RemoveChild(avmfNode["duration"]);
}
return(xmlDoc);
}
/// <summary>
/// Can be used to determine if the slow provider update has completed.
/// </summary>
/// <returns></returns>
public bool AllSlowUpdateTasksCompleted()
{
return(InfoProviderBase.AllSlowUpdateTasksCompleted());
}
/// <summary>
/// Creates a task that will start all infoProvider slow update queues
/// Method returns as soon as the task is started, i.e. not necessary once it's completed
/// Use WaitForSlowProviderUpdateToComplete()
/// </summary>
public void BeginSlowProviderUpdate(List <InfoProviderType> providersToUpdate)
{
InfoProviderBase.InitiateSlowTasks(providersToUpdate);
}
/// <summary>
/// If the slowupdate task is running this will return once it is complete.
/// If the task is not running this will return immediately.
/// </summary>
public void WaitForSlowProviderUpdateToComplete()
{
InfoProviderBase.WaitForSlowTasksToComplete();
}
