Ejemplo n.º 1
0
        public static string CreateMediaInfoDump(string filePath)
        {
            IMediaInfo mi = CreateMediaInfoInstance();

            mi.Open(filePath);
            mi.Option("Complete", "1");

            string dump = mi.Inform();

            mi.Close();

            return(dump);
        }
Ejemplo n.º 2
0
        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);
        }
Ejemplo n.º 3
0
        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);
        }
Ejemplo n.º 4
0
 private void Close()
 {
     _mediaInfo.Close();
 }