public static async Task<long> GetDurationValue(this IMediaInfo mediaInfo, StreamKind streamKind, string parameter)
 {
     string textValue = await mediaInfo.Get(streamKind, 0, parameter);
     TimeSpan timeSpanValue;
     TimeSpan.TryParse(textValue, CultureInfo, out timeSpanValue);
     return (long)timeSpanValue.TotalMilliseconds;
 }

        public async Task<string> Get(StreamKind streamKind, int streamNumber, string parameter)
        {
            if (_handle == (IntPtr)0)
            {
                return "Unable to load MediaInfo library";
            }

            if (_mustUseAnsi)
            {
                IntPtr parameterPtr = Marshal.StringToHGlobalAnsi(parameter);
                string toReturn = Marshal.PtrToStringAnsi(
                    await MediaInfoInterop.GetAnsiAsync(
                        _handle,
                        (IntPtr)streamKind,
                        (IntPtr)streamNumber,
                        parameterPtr,
                        (IntPtr)InfoKind.Text,
                        (IntPtr)InfoKind.Name));
                Marshal.FreeHGlobal(parameterPtr);
                return toReturn;
            }

            return Marshal.PtrToStringUni(
                await MediaInfoInterop.GetAsync(
                    _handle,
                    (IntPtr)streamKind,
                    (IntPtr)streamNumber,
                    parameter,
                    (IntPtr)InfoKind.Text,
                    (IntPtr)InfoKind.Name));
        }

 public static async Task<long> GetLongValue(this IMediaInfo mediaInfo, StreamKind streamKind, string parameter)
 {
     string textValue = await mediaInfo.Get(streamKind, 0, parameter);
     long longValue;
     long.TryParse(textValue, NumberStyles.Integer, CultureInfo, out longValue);
     return longValue;
 }

 public static async Task<double> GetDoubleValue(this IMediaInfo mediaInfo, StreamKind streamKind, string parameter)
 {
     string textValue = await mediaInfo.Get(streamKind, 0, parameter);
     double doubleValue;
     double.TryParse(textValue, NumberStyles.Float, CultureInfo, out doubleValue);
     return doubleValue;
 }

 public static async Task<int> GetIntegerValue(this IMediaInfo mediaInfo, StreamKind streamKind, string parameter)
 {
     string textValue = await mediaInfo.Get(streamKind, 0, parameter);
     int integerValue;
     int.TryParse(textValue, NumberStyles.Integer, CultureInfo, out integerValue);
     return integerValue;
 }

 private short? GetLength(StreamKind stream) {
     string StrValue = lastMedia.Get(stream, 0, "Duration");
     int Result = 0;
     if (int.TryParse(StrValue, out Result))
         return (short)(Result / 1000);
     else
         return null;
 }

 public static async Task<DateTime> GetDateValue(this IMediaInfo mediaInfo, StreamKind streamKind, string parameter)
 {
     string textValue = await mediaInfo.Get(streamKind, 0, parameter);
     textValue = textValue.Replace("UTC ", string.Empty);
     DateTime dateValue;
     DateTime.TryParse(textValue, CultureInfo, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out dateValue);
     return dateValue;
 }

 ///<summary>Used to create a stream-specific object, such as an audio
 ///stream, for use by an existing MediaFile object.</summary>
 ///<param name="mediaInfo">A pre-initialized MediaInfo object.</param>
 ///<param name="kind">A defined value from StreamKind enum.</param>
 ///<param name="id">The MediaInfo ID for this stream.</param>
 public Media(MediaInfo mediaInfo, StreamKind kind, int id)
 {
     string errorText;
     this.mediaInfo = mediaInfo;
     if (mediaInfo == null) {
         errorText = "MediaInfo object cannot be null.";
         throw new ArgumentNullException(errorText);
     }
     if (!isMediaInfoDllCompatible()) {
         errorText = "Incompatible version of MediaInfo.DLL";
         throw new InvalidOperationException(errorText);
     }
     this.kind = kind;
     if (!Enum.IsDefined(typeof(StreamKind), (object)kind)) {
         errorText = "Invalid value for StreamKind";
         throw new ArgumentOutOfRangeException(errorText);
     }
     this.id = id;
 }

 public String Get(int FilePos, StreamKind StreamKind, int StreamNumber, String Parameter, InfoKind KindOfInfo)
 {
     return Get(FilePos, StreamKind, StreamNumber, Parameter, KindOfInfo, InfoKind.Name);
 }

 public int Count_Get(int FilePos, StreamKind StreamKind)
 {
     return Count_Get(FilePos, StreamKind, -1);
 }

 ///<summary>MultiStreamCommon constructor.</summary>
 ///<param name="mediaInfo">A MediaInfo object.</param>
 ///<param name="kind">A MediaInfo StreamKind.</param>
 ///<param name="id">The MediaInfo ID for this audio stream.</param>
 public BaseStreamCommons(MediaInfo mediaInfo, StreamKind kind, int id)
     : base(mediaInfo, kind, id)
 {
 }

 public string Get(StreamKind streamKind, int streamNumber, int parameter, InfoKind infoKind)
 {
     if (MustUseAnsi)
     {
         return MakeStringResult(MediaInfoA_GetI(_handle, (IntPtr)streamKind, (IntPtr)streamNumber, (IntPtr)parameter, (IntPtr)infoKind));
     }
     else
     {
         return MakeStringResult(MediaInfo_GetI(_handle, (IntPtr)streamKind, (IntPtr)streamNumber, (IntPtr)parameter, (IntPtr)infoKind));
     }
 }

 private string GetFullCodecName(StreamKind type, int audiotrack)
 {
   string strCodec = _mI.Get(type, 0, "Format").ToUpper();
   string strCodecVer = _mI.Get(type, 0, "Format_Version").ToUpper();
   if (strCodec == "MPEG-4 VISUAL")
   {
     strCodec = _mI.Get(type, 0, "CodecID").ToUpper();
   }
   else
   {
     if (!String.IsNullOrEmpty(strCodecVer))
     {
       strCodec = (strCodec + " " + strCodecVer).Trim();
       string strCodecProf = _mI.Get(type, 0, "Format_Profile").ToUpper();
       if (type == StreamKind.Video && strCodecProf != "[email protected]")
       {
         strCodec = (strCodec + " " + strCodecProf).Trim();
       }
     }
   }
   if (type == StreamKind.Audio)
   {
     strCodec =
       (strCodec + " " + _mI.Get(type, audiotrack, "Format_Profile").Split(new char[] {'/'})[0].ToUpper()).Trim();
   }
   //
   // Workarround because skin engine ( string.equals/string.contains ) doesn't handle the "+" as last digit
   //
   return strCodec.Replace("+", "PLUS");
 }

 public String Get(int filePos, StreamKind streamKind, int streamNumber, String parameter, InfoKind kindOfInfo)
 {
     return Get(filePos, streamKind, streamNumber, parameter, kindOfInfo, InfoKind.Name);
 }

 public String Get(StreamKind StreamKind, int StreamNumber, String Parameter, InfoKind KindOfInfo,
     InfoKind KindOfSearch)
 {
     return
     Marshal.PtrToStringUni(MediaInfo_Get(Handle, (IntPtr)StreamKind, (IntPtr)StreamNumber, Parameter,
                                      (IntPtr)KindOfInfo, (IntPtr)KindOfSearch));
 }

 public int Count_Get(int filePos, StreamKind streamKind)
 {
     return Count_Get(filePos, streamKind, -1);
 }

 private static int GetInt(this MediaInfo mi, StreamKind kind, int number, string par)
 {
     int val;
     string dta = mi.Get(kind, number, par);
     if (int.TryParse(dta, out val))
         return val;
     return 0;
 }

 private static float GetFloat(this MediaInfo mi, StreamKind kind, int number, string par)
 {
     float val;
     string dta = mi.Get(kind, number, par);
     if (float.TryParse(dta, out val))
         return val;
     return 0.0F;
 }