private void Open(string filePath)
{
if (_mediaInfo.Open(filePath) <= 0)
{
throw new MediaFormatException("FilePath");
}
}
public static string CreateMediaInfoDump(string filePath)
{
IMediaInfo mi = CreateMediaInfoInstance();
mi.Open(filePath);
mi.Option("Complete", "1");
string dump = mi.Inform();
mi.Close();
return(dump);
}
public static XmlDocument CreateMediaInfoXMLLog(string filePath, IEnumerable <IBlockConsumer> blockConsumers)
{
XmlDocument xmlDoc = new XmlDocument();
XmlNode node, subNode;
IMediaInfo mediaInfo = CreateMediaInfoInstance();
mediaInfo.Open(filePath);
node = xmlDoc.AppendChild(xmlDoc.CreateElement("File"));
subNode = node.AppendChild(xmlDoc.CreateElement("Hashes"));
AppendLeaf(xmlDoc, subNode, "Size", (new FileInfo(filePath)).Length.ToString(), null);
if (blockConsumers != null)
{
foreach (HashCalculator hashExecute in blockConsumers.Where(blockConsumer => { return(blockConsumer is HashCalculator); }))
{
AppendLeaf(xmlDoc, subNode, hashExecute.Name, BaseConverter.ToString(hashExecute.HashObj.Hash), null);
if (hashExecute.HashObj is Ed2k)
{
Ed2k ed2k = (Ed2k)hashExecute.HashObj;
if (!ed2k.BlueIsRed)
{
AppendLeaf(xmlDoc, subNode, "Ed2k_Alt", BaseConverter.ToString(ed2k.BlueHash), null);
}
}
}
}
int streamCount, entryCount;
string name, text, measure;
foreach (eStreamType streamKind in Enum.GetValues(typeof(eStreamType)))
{
streamCount = mediaInfo.Count_Get(streamKind);
for (int i = 0; i < streamCount; i++)
{
entryCount = mediaInfo.Count_Get(streamKind, i);
subNode = node.AppendChild(xmlDoc.CreateElement(streamKind.ToString()));
for (int j = 0; j < entryCount; j++)
{
name = mediaInfo.Get(streamKind, i, j, eInfoType.Name).Replace("/", "-").Replace("(", "").Replace(")", "");
if (name.Equals("Chapters_Pos_End") || name.Equals("Chapters_Pos_Begin") || name.Contains("-String"))
{
continue;
}
if (name.Equals("Bits-Pixel*Frame"))
{
name = "BitsPerPixel";
}
text = mediaInfo.Get(streamKind, i, j, eInfoType.Text);
measure = mediaInfo.Get(streamKind, i, j, eInfoType.Measure).Trim();
if (name.IndexOfAny(new char[] { ')', ':' }) < 0 && !String.IsNullOrEmpty(text))
{
AppendLeaf(xmlDoc, subNode, name, text, String.IsNullOrEmpty(measure) ? null : new string[, ] {
{ "Unit", measure }
});
}
else
{
//Debug.Print(name + " " + text + " " + measure);
}
}
if (streamKind == eStreamType.Menu)
{
int indexStart;
int indexEnd;
XmlNode chapterNode;
if (int.TryParse(mediaInfo.Get(streamKind, i, "Chapters_Pos_Begin"), out indexStart) && int.TryParse(mediaInfo.Get(streamKind, i, "Chapters_Pos_End"), out indexEnd))
{
chapterNode = subNode.AppendChild(xmlDoc.CreateElement("Chapters"));
for (; indexStart < indexEnd; indexStart++)
{
AppendLeaf(xmlDoc, chapterNode, "Chapter", mediaInfo.Get(streamKind, i, indexStart, eInfoType.Text), new string[, ] {
{ "TimeStamp", mediaInfo.Get(streamKind, i, indexStart, eInfoType.Name) }
});
}
}
}
}
}
mediaInfo.Close();
return(xmlDoc);
}
public async Task <IVideoMetadata> GetVideoMetadata(string fileName)
{
if (string.IsNullOrEmpty(fileName))
{
throw new ArgumentNullException("fileName");
}
IMediaInfo mediaInfo = await MediaInfoPromise;
if (await mediaInfo.Open(fileName) == 0)
{
throw new IOException(string.Format("Failed to open media file: {0}", fileName));
}
VideoMetadata metadata = null;
Exception exception = null;
try
{
metadata = new VideoMetadata
{
GeneralFormat = await mediaInfo.GetStringValue(StreamKind.General, "Format"),
GeneralFormatProfile = await mediaInfo.GetStringValue(StreamKind.General, "Format_Profile"),
GeneralCodecID = await mediaInfo.GetStringValue(StreamKind.General, "CodecID"),
GeneralFileSize = await mediaInfo.GetLongValue(StreamKind.General, "FileSize"),
GeneralDuration = await mediaInfo.GetDurationValue(StreamKind.General, "Duration/String3"),
GeneralOverallBitRate = await mediaInfo.GetIntegerValue(StreamKind.General, "BitRate"),
GeneralEncodedDate = FixDateTime(await mediaInfo.GetDateValue(StreamKind.General, "Encoded_Date")),
GeneralTaggedDate = FixDateTime(await mediaInfo.GetDateValue(StreamKind.General, "Tagged_Date")),
VideoStreamsCount = await mediaInfo.GetIntegerValue(StreamKind.Video, "StreamCount"),
VideoFormat = await mediaInfo.GetStringValue(StreamKind.Video, "Format"),
VideoFormatInfo = await mediaInfo.GetStringValue(StreamKind.Video, "Format/Info"),
VideoFormatProfile = await mediaInfo.GetStringValue(StreamKind.Video, "Format_Profile"),
VideoFormatSettingsCABAC = await mediaInfo.GetStringValue(StreamKind.Video, "Format_Settings_CABAC"),
VideoFormatSettingsRefFrames = await mediaInfo.GetIntegerValue(StreamKind.Video, "Format_Settings_RefFrames"),
VideoFormatSettingsGOP = await mediaInfo.GetStringValue(StreamKind.Video, "Format_Settings_GOP"),
VideoCodecID = await mediaInfo.GetStringValue(StreamKind.Video, "CodecID"),
VideoCodecIDInfo = await mediaInfo.GetStringValue(StreamKind.Video, "CodecID/Info"),
VideoDuration = await mediaInfo.GetDurationValue(StreamKind.Video, "Duration/String3"),
VideoBitRateMode = await mediaInfo.GetStringValue(StreamKind.Video, "BitRate_Mode"),
VideoBitRate = await mediaInfo.GetIntegerValue(StreamKind.Video, "BitRate"),
VideoBitRateMinimum = await mediaInfo.GetIntegerValue(StreamKind.Video, "BitRate_Minimum"),
VideoBitRateMaximum = await mediaInfo.GetIntegerValue(StreamKind.Video, "BitRate_Maximum"),
VideoBitRateNominal = await mediaInfo.GetIntegerValue(StreamKind.Video, "BitRate_Nominal"),
VideoWidth = await mediaInfo.GetIntegerValue(StreamKind.Video, "Width"),
VideoHeight = await mediaInfo.GetIntegerValue(StreamKind.Video, "Height"),
VideoDisplayAspectRatio = await mediaInfo.GetStringValue(StreamKind.Video, "DisplayAspectRatio/String"),
VideoFrameRateMode = await mediaInfo.GetStringValue(StreamKind.Video, "FrameRate_Mode"),
VideoFrameRate = await mediaInfo.GetDoubleValue(StreamKind.Video, "FrameRate"),
VideoFrameRateMinimum = await mediaInfo.GetDoubleValue(StreamKind.Video, "FrameRate_Minimum"),
VideoFrameRateMaximum = await mediaInfo.GetDoubleValue(StreamKind.Video, "FrameRate_Maximum"),
VideoFrameRateOriginal = await mediaInfo.GetDoubleValue(StreamKind.Video, "FrameRate_Original"),
VideoColorSpace = await mediaInfo.GetStringValue(StreamKind.Video, "ColorSpace"),
VideoChromaSubsampling = await mediaInfo.GetStringValue(StreamKind.Video, "Colorimetry"),
VideoBitDepth = await mediaInfo.GetIntegerValue(StreamKind.Video, "Resolution"),
VideoScanType = await mediaInfo.GetStringValue(StreamKind.Video, "ScanType"),
VideoBitsPixelByFrame = await mediaInfo.GetDoubleValue(StreamKind.Video, "Bits-(Pixel*Frame)"),
VideoStreamSize = await mediaInfo.GetLongValue(StreamKind.Video, "StreamSize"),
VideoTitle = await mediaInfo.GetStringValue(StreamKind.Video, "Title"),
VideoLanguage = await mediaInfo.GetStringValue(StreamKind.Video, "Language"),
VideoEncodedDate = FixDateTime(await mediaInfo.GetDateValue(StreamKind.Video, "Encoded_Date")),
VideoTaggedDate = FixDateTime(await mediaInfo.GetDateValue(StreamKind.Video, "Tagged_Date")),
VideoRotation = await mediaInfo.GetDoubleValue(StreamKind.Video, "Rotation"),
AudioStreamsCount = await mediaInfo.GetIntegerValue(StreamKind.Audio, "StreamCount"),
AudioFormat = await mediaInfo.GetStringValue(StreamKind.Audio, "Format"),
AudioFormatInfo = await mediaInfo.GetStringValue(StreamKind.Audio, "Format/Info"),
AudioFormatProfile = await mediaInfo.GetStringValue(StreamKind.Audio, "Format_Profile"),
AudioCodecID = await mediaInfo.GetStringValue(StreamKind.Audio, "CodecID"),
AudioDuration = await mediaInfo.GetDurationValue(StreamKind.Audio, "Duration/String3"),
AudioBitRateMode = await mediaInfo.GetStringValue(StreamKind.Audio, "BitRate_Mode"),
AudioBitRate = await mediaInfo.GetIntegerValue(StreamKind.Audio, "BitRate"),
AudioBitRateMinimum = await mediaInfo.GetIntegerValue(StreamKind.Audio, "BitRate_Minimum"),
AudioBitRateMaximum = await mediaInfo.GetIntegerValue(StreamKind.Audio, "BitRate_Maximum"),
AudioBitRateNominal = await mediaInfo.GetIntegerValue(StreamKind.Audio, "BitRate_Nominal"),
AudioChannels = await mediaInfo.GetIntegerValue(StreamKind.Audio, "Channel(s)"),
AudioChannelPositions = await mediaInfo.GetStringValue(StreamKind.Audio, "ChannelPositions"),
AudioSamplingRate = await mediaInfo.GetIntegerValue(StreamKind.Audio, "SamplingRate"),
AudioCompressionMode = await mediaInfo.GetStringValue(StreamKind.Audio, "Compression_Mode"),
AudioStreamSize = await mediaInfo.GetLongValue(StreamKind.Audio, "StreamSize"),
AudioTitle = await mediaInfo.GetStringValue(StreamKind.Audio, "Title"),
AudioLanguage = await mediaInfo.GetStringValue(StreamKind.Audio, "Language"),
AudioEncodedDate = FixDateTime(await mediaInfo.GetDateValue(StreamKind.Audio, "Encoded_Date")),
AudioTaggedDate = FixDateTime(await mediaInfo.GetDateValue(StreamKind.Audio, "Tagged_Date"))
};
}
catch (Exception e)
{
exception = e;
}
await mediaInfo.Close();
if (exception != null)
{
throw new ApplicationException(string.Format("Failed to receive metadata for file {0}", fileName), exception);
}
return(metadata);
}
public MediaInfoProvider(string filePath)
{
infos = new InfoCollection();
Func <string, string, string> nonEmpty = (a, b) => string.IsNullOrEmpty(a) ? b : a;
MIL = IntPtr.Size == 8 ? (IMediaInfo) new MediaInfo_x64() : (IMediaInfo) new MediaInfo_x86();
MIL.Option("Internet", "No");
//if(!MIL.Option("Info_Version").Equals("MediaInfoLib - v0.7.42")) throw new Exception("Mediainfo library version mismatch. Needed: v0.7.42, Used: " + MIL.Option("Info_Version"));
MIL.Open(filePath);
Add(EntryKey.Size, Get("FileSize"), "byte");
Add(EntryKey.Duration, Get("Duration", str => (double.Parse(str, CultureInfo.InvariantCulture) / 1000d).ToString("0.000", CultureInfo.InvariantCulture)), "s");
Add(EntryKey.FileExtension, Get("FileExtension") != null ? Get("FileExtension").ToLower() : null, null);
Add(EntryKey.WritingApp, Get("Encoded_Application"), null);
Add(EntryKey.MuxingApp, Get("Encoded_Library"), null);
double dummy;
StreamType st;
int streamCount;
int[] indeces = new int[3];
Converter <eStreamType, StreamType> streamConverter = a => a == eStreamType.Video ? StreamType.Video : (a == eStreamType.Audio ? StreamType.Audio : (a == eStreamType.Text ? StreamType.Text : (StreamType)(-1)));
foreach (eStreamType streamKind in Enum.GetValues(typeof(eStreamType)))
{
streamCount = MIL.Count_Get(streamKind);
st = streamConverter(streamKind);
if ((int)st == -1)
{
continue;
}
for (int i = 0; i < streamCount; i++)
{
Add(st, i, EntryKey.Size, Get(streamKind, i, "StreamSize"), "byte");
Add(st, i, EntryKey.Title, Get(streamKind, i, "Title"), null);
Add(st, i, EntryKey.Id, Get(streamKind, i, "UniqueID"), null);
Add(st, i, EntryKey.Language, Get(streamKind, i, "Language"), null);
Add(st, i, EntryKey.Duration, Get(streamKind, i, "Duration", str => (double.Parse(str.Split('/')[0], CultureInfo.InvariantCulture) / 1000).ToString("0.000", CultureInfo.InvariantCulture)), "s");
Add(st, i, EntryKey.Bitrate, () => Get(streamKind, i, "BitRate").Split('/').First(e => double.TryParse(e, out dummy)), null);
Add(st, i, EntryKey.CodecId, ((Get(streamKind, i, "Format") + " -- " + nonEmpty(Get(streamKind, i, "Format_Version"), Get(streamKind, i, "CodecID"))).Trim() + " -- " + Get(streamKind, i, "Format_Profile").Split('/')[0]).Trim(), null);
Add(st, i, EntryKey.CodecIdAlt, Get(streamKind, i, "CodecID"), null);
Add(st, i, EntryKey.EncodeSettings, Get(streamKind, i, "Encoded_Library_Settings"), null);
Add(st, i, EntryKey.EncodeLibrary, Get(streamKind, i, "Encoded_Library"), null);
Add(st, i, EntryKey.BitrateMode, Get(streamKind, i, "BitRate_Mode"), null);
switch (streamKind)
{
case eStreamType.Video:
Add(st, i, EntryKey.FrameRate, Get(streamKind, i, "FrameRate").Split('/')[0].Trim(), null);
Add(st, i, EntryKey.MaxFrameRate, Get(streamKind, i, "FrameRate_Maximum"), null);
Add(st, i, EntryKey.MinFrameRate, Get(streamKind, i, "FrameRate_Minimum"), null);
Add(st, i, EntryKey.VFR, Get(streamKind, i, "FrameRate_Mode").Contains("VFR") ? Get(streamKind, i, "FrameRate") : null, null);
Add(st, i, EntryKey.FrameCount, Get(streamKind, i, "FrameCount"), null);
Add(st, i, EntryKey.Width, () => Get(streamKind, i, "Width").Split('/')[0], null);
Add(st, i, EntryKey.ColorBitDepth, Get(streamKind, i, "BitDepth"), null);
Add(st, i, EntryKey.Height, () => Get(streamKind, i, "Height").Split('/')[0], null);
Add(st, i, EntryKey.DAR, Get(streamKind, i, "DisplayAspectRatio"), null);
Add(st, i, EntryKey.PAR, () => double.Parse(Get(streamKind, i, "PixelAspectRatio")) != 1 ? Get(streamKind, i, "PixelAspectRatio") : null, null);
indeces[0]++;
break;
case eStreamType.Audio:
Add(st, i, EntryKey.SamplingRate, Get(streamKind, i, "SamplingRate").Split('/')[0], null);
Add(st, i, EntryKey.SampleCount, Get(streamKind, i, "SamplingCount").Split('/')[0], null);
Add(st, i, EntryKey.ChannelCount, Get(streamKind, i, "Channel(s)").Split('/')[0], null);
indeces[1]++;
break;
case eStreamType.Text:
indeces[2]++;
break;
}
}
}
string milInfo = Get("Format/Extensions") != null?Get("Format/Extensions").ToLower() : "";
//string fileExt = System.IO.Path.GetExtension(filePath).ToLower();
if (milInfo.Contains("asf") && milInfo.Contains("wmv") && milInfo.Contains("wma"))
{
if (indeces[0] == 0 && indeces[1] != 0 && indeces[2] == 0)
{
Add(EntryKey.Extension, "wma", null);
}
else
{
Add(EntryKey.Extension, "wmv", null);
}
}
else if (milInfo.Contains("ts") && milInfo.Contains("m2t"))
{
if (System.IO.Path.GetExtension(filePath).Equals(".ts"))
{
Add(EntryKey.Extension, "ts", null); //Blame worf
}
}
else if (milInfo.Contains("mpeg") && milInfo.Contains("mpg"))
{
if (indeces[0] == 0 || indeces[1] == 0 && indeces[1] != 0)
{
Add(EntryKey.Extension, "sub", null);
}
else
{
Add(EntryKey.Extension, "mpg", null);
}
}
else if ((milInfo.Contains("mp1") && milInfo.Contains("mp2") && milInfo.Contains("mp3")) || milInfo.Contains("wav"))
{
switch (Get(eStreamType.Audio, 0, "Format_Profile"))
{
case "Layer 1": Add(EntryKey.Extension, "mp1", null); break;
case "Layer 2": Add(EntryKey.Extension, "mp2", null); break;
case "Layer 3": Add(EntryKey.Extension, "mp3", null); break;
}
}
else if (milInfo.Contains("mp4") && milInfo.Contains("m4a") && milInfo.Contains("m4v"))
{
/*if(indeces[2] != 0 || (indeces[0] != 0 && indeces[1] != 0)) {
* Add(EntryKey.Extension, "mp4", null);
* } else if(indeces[0] != 0 && indeces[1] == 0) {
* Add(EntryKey.Extension, "m4v", null);
* } else if(indeces[0] == 0 && indeces[1] != 0) {
* Add(EntryKey.Extension, "m4a", null);
* }*/
if (indeces[0] == 0 && indeces[2] == 0 && indeces[1] != 0)
{
Add(EntryKey.Extension, "m4a", null);
}
else if (indeces[0] != 0 && indeces[1] == 0 && indeces[2] == 0)
{
Add(EntryKey.Extension, "m4v", null);
}
else
{
Add(EntryKey.Extension, "mp4", null);
}
}
else if (milInfo.Contains("dts"))
{
milInfo = Get(eStreamType.General, 0, "Audio_Codec_List").ToLower();
if (milInfo.Contains("dts-hd"))
{
Add(EntryKey.Extension, "dtshd", null);
}
else if (milInfo.Contains("truehd"))
{
Add(EntryKey.Extension, "thd", null);
}
else
{
Add(EntryKey.Extension, "dts", null);
}
}
if (this[StreamType.General, 0, EntryKey.Extension] == null)
{
if (milInfo.Contains("rm") || milInfo.Contains("rmvb"))
{
Add(EntryKey.Extension, "rm", null);
}
if (milInfo.Contains("asf") || milInfo.Contains("wmv") /*|| milInfo.Contains("wma")*/)
{
Add(EntryKey.Extension, "wmv", null);
}
if (milInfo.Contains("mov") || milInfo.Contains("qt"))
{
Add(EntryKey.Extension, "mov", null);
}
}
if (this[StreamType.General, 0, EntryKey.Extension] == null)
{
Add(EntryKey.Extension, milInfo.Split(' ')[0], null);
}
}
