protected bool BDROM_StreamFileScanError(TSStreamFile streamFile, Exception ex) { System.Console.WriteLine(string.Format( "An error occurred while scanning the stream file {0}.\n\nThe disc may be copy-protected or damaged.\n\nDo you want to continue scanning the stream files?", streamFile.Name)); return(GetYorNdefaultY()); }
public int CompareStreamFiles( TSStreamFile x, TSStreamFile y) { // TODO: Use interleaved file sizes if ((x == null || x.FileInfo == null) && (y == null || y.FileInfo == null)) { return(0); } else if ((x == null || x.FileInfo == null) && (y != null && y.FileInfo != null)) { return(1); } else if ((x != null || x.FileInfo != null) && (y == null || y.FileInfo == null)) { return(-1); } else { if (x.FileInfo.Length > y.FileInfo.Length) { return(1); } else if (y.FileInfo.Length > x.FileInfo.Length) { return(-1); } else { return(0); } } }
public TSStreamClip( TSStreamFile streamFile, TSStreamClipFile streamClipFile) { if (streamFile != null) { Name = streamFile.Name; StreamFile = streamFile; if (StreamFile.FileInfo != null) { FileSize = (ulong)StreamFile.FileInfo.Length; } else { FileSize = (ulong)StreamFile.DFileInfo.Length; } if (StreamFile.InterleavedFile != null) { if (StreamFile.InterleavedFile.FileInfo != null) { InterleavedFileSize = (ulong)StreamFile.InterleavedFile.FileInfo.Length; } else { InterleavedFileSize = (ulong)StreamFile.InterleavedFile.DFileInfo.Length; } } } StreamClipFile = streamClipFile; }
public TSStreamClip( TSStreamFile streamFile, TSStreamClipFile streamClipFile) { Name = streamFile.Name; StreamFile = streamFile; StreamClipFile = streamClipFile; FileSize = (ulong)StreamFile.FileInfo.Length; }
private void ScanBDROMThread( object parameter ) { ScanBDROMState scanState = (ScanBDROMState)parameter; try { TSStreamFile streamFile = scanState.StreamFile; List <TSPlaylistFile> playlists = scanState.PlaylistMap[streamFile.Name]; streamFile.Scan(playlists, true); } catch (Exception ex) { scanState.Exception = ex; } }
public TSStreamClip( TSStreamFile streamFile, TSStreamClipFile streamClipFile) { if (streamFile != null) { Name = streamFile.Name; StreamFile = streamFile; FileSize = (ulong)StreamFile.FileInfo.Length; if (StreamFile.InterleavedFile != null) { InterleavedFileSize = (ulong)StreamFile.InterleavedFile.FileInfo.Length; } } StreamClipFile = streamClipFile; }
public TSStreamClip( TSStreamFile streamFile, TSStreamClipFile streamClipFile) { if (streamFile != null) { _settings = ServiceRegistration.Get <ISettingsManager>().Load <BDInfoSettings>() ?? new BDInfoSettings(); Name = streamFile.Name; StreamFile = streamFile; FileSize = (ulong)StreamFile.FileInfo.Length; if (StreamFile.InterleavedFile != null) { InterleavedFileSize = (ulong)StreamFile.InterleavedFile.FileInfo.Length; } } StreamClipFile = streamClipFile; }
public TSStreamClip( TSStreamFile streamFile, TSStreamClipFile streamClipFile) { if (streamFile != null) { _settings = ServiceRegistration.Get<ISettingsManager>().Load<BDInfoSettings>() ?? new BDInfoSettings(); Name = streamFile.Name; StreamFile = streamFile; FileSize = (ulong)StreamFile.FileInfo.Length; if (StreamFile.InterleavedFile != null) { InterleavedFileSize = (ulong)StreamFile.InterleavedFile.FileInfo.Length; } } StreamClipFile = streamClipFile; }
public static string Generate(BDROM BDROM, List <TSPlaylistFile> playlists, ScanBDROMResult scanResult) { var report = new StringBuilder(); var protection = BDROM.IsBDPlus ? "BD+" : BDROM.IsUHD ? "AACS2" : "AACS"; if (!string.IsNullOrEmpty(BDROM.DiscTitle)) { report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-16}{1}\r\n", "Disc Title:", BDROM.DiscTitle)); } report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-16}{1}\r\n", "Disc Label:", BDROM.VolumeLabel)); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-16}{1:N0} bytes\r\n", "Disc Size:", BDROM.Size)); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-16}{1}\r\n", "Protection:", protection)); var extraFeatures = new List <string>(); if (BDROM.IsUHD) { extraFeatures.Add("Ultra HD"); } if (BDROM.IsBDJava) { extraFeatures.Add("BD-Java"); } if (BDROM.Is50Hz) { extraFeatures.Add("50Hz Content"); } if (BDROM.Is3D) { extraFeatures.Add("Blu-ray 3D"); } if (BDROM.IsDBOX) { extraFeatures.Add("D-BOX Motion Code"); } if (BDROM.IsPSP) { extraFeatures.Add("PSP Digital Copy"); } if (extraFeatures.Count > 0) { report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-16}{1}\r\n", "Extras:", string.Join(", ", extraFeatures.ToArray()))); } /*report.Append(string.Format( CultureInfo.InvariantCulture, * "{0,-16}{1}\r\n", "BDInfo:", * Application.ProductVersion);*/ report.Append("\r\n"); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-16}{1}\r\n", "Notes:", "")); report.Append("\r\n"); report.Append("BDINFO HOME:\r\n"); report.Append(" Cinema Squid (old)\r\n"); report.Append(" http://www.cinemasquid.com/blu-ray/tools/bdinfo\r\n"); report.Append(" UniqProject GitHub (new)\r\n"); report.Append(" https://github.com/UniqProject/BDInfo\r\n"); report.Append("\r\n"); report.Append("INCLUDES FORUMS REPORT FOR:\r\n"); report.Append(" AVS Forum Blu-ray Audio and Video Specifications Thread\r\n"); report.Append(" http://www.avsforum.com/avs-vb/showthread.php?t=1155731\r\n"); report.Append("\r\n"); if (scanResult.ScanException != null) { report.Append(string.Format(CultureInfo.InvariantCulture, "WARNING: Report is incomplete because: {0}\r\n", scanResult.ScanException.Message)); } if (scanResult.FileExceptions.Count > 0) { report.Append("WARNING: File errors were encountered during scan:\r\n"); foreach (var fileName in scanResult.FileExceptions.Keys) { var fileException = scanResult.FileExceptions[fileName]; report.Append(string.Format(CultureInfo.InvariantCulture, "\r\n{0}\t{1}\r\n", fileName, fileException.Message)); report.Append(string.Format(CultureInfo.InvariantCulture, "{0}\r\n", fileException.StackTrace)); } } foreach (var playlist in playlists) { var summary = ""; // comboBoxPlaylist.Items.Add(playlist); var title = playlist.Name; var discSize = string.Format(CultureInfo.InvariantCulture, "{0:N0}", BDROM.Size); var playlistTotalLength = new TimeSpan((long)(playlist.TotalLength * 10000000)); var totalLength = string.Format(CultureInfo.InvariantCulture, "{0:D1}:{1:D2}:{2:D2}.{3:D3}", playlistTotalLength.Hours, playlistTotalLength.Minutes, playlistTotalLength.Seconds, playlistTotalLength.Milliseconds); var totalLengthShort = string.Format(CultureInfo.InvariantCulture, "{0:D1}:{1:D2}:{2:D2}", playlistTotalLength.Hours, playlistTotalLength.Minutes, playlistTotalLength.Seconds); var totalSize = string.Format(CultureInfo.InvariantCulture, "{0:N0}", playlist.TotalSize); var totalBitrate = string.Format(CultureInfo.InvariantCulture, "{0:F2}", Math.Round((double)playlist.TotalBitRate / 10000) / 100); var playlistAngleLength = new TimeSpan((long)(playlist.TotalAngleLength * 10000000)); var totalAngleLength = string.Format(CultureInfo.InvariantCulture, "{0:D1}:{1:D2}:{2:D2}.{3:D3}", playlistAngleLength.Hours, playlistAngleLength.Minutes, playlistAngleLength.Seconds, playlistAngleLength.Milliseconds); var totalAngleSize = string.Format(CultureInfo.InvariantCulture, "{0:N0}", playlist.TotalAngleSize); var totalAngleBitrate = string.Format(CultureInfo.InvariantCulture, "{0:F2}", Math.Round((double)playlist.TotalAngleBitRate / 10000) / 100); var angleLengths = new List <string>(); var angleSizes = new List <string>(); var angleBitrates = new List <string>(); var angleTotalLengths = new List <string>(); var angleTotalSizes = new List <string>(); var angleTotalBitrates = new List <string>(); if (playlist.AngleCount > 0) { for (var angleIndex = 0; angleIndex < playlist.AngleCount; angleIndex++) { double angleLength = 0; ulong angleSize = 0; ulong angleTotalSize = 0; if (angleIndex < playlist.AngleClips.Count && playlist.AngleClips[angleIndex] != null) { foreach (var clip in playlist.AngleClips[angleIndex].Values) { angleTotalSize += clip.PacketSize; if (clip.AngleIndex == angleIndex + 1) { angleSize += clip.PacketSize; angleLength += clip.Length; } } } angleSizes.Add(string.Format(CultureInfo.InvariantCulture, "{0:N0}", angleSize)); var angleTimeSpan = new TimeSpan((long)(angleLength * 10000000)); angleLengths.Add(string.Format(CultureInfo.InvariantCulture, "{0:D1}:{1:D2}:{2:D2}.{3:D3}", angleTimeSpan.Hours, angleTimeSpan.Minutes, angleTimeSpan.Seconds, angleTimeSpan.Milliseconds)); angleTotalSizes.Add(string.Format(CultureInfo.InvariantCulture, "{0:N0}", angleTotalSize)); angleTotalLengths.Add(totalLength); double angleBitrate = 0; if (angleLength > 0) { angleBitrate = Math.Round(angleSize * 8 / angleLength / 10000) / 100; } angleBitrates.Add(string.Format(CultureInfo.InvariantCulture, "{0:F2}", angleBitrate)); double angleTotalBitrate = 0; if (playlist.TotalLength > 0) { angleTotalBitrate = Math.Round(angleTotalSize * 8 / playlist.TotalLength / 10000) / 100; } angleTotalBitrates.Add(string.Format(CultureInfo.InvariantCulture, "{0:F2}", angleTotalBitrate)); } } var videoCodec = ""; var videoBitrate = ""; if (playlist.VideoStreams.Count > 0) { TSStream videoStream = playlist.VideoStreams[0]; videoCodec = videoStream.CodecAltName; videoBitrate = string.Format(CultureInfo.InvariantCulture, "{0:F2}", Math.Round((double)videoStream.BitRate / 10000) / 100); } var audio1 = ""; var languageCode1 = ""; if (playlist.AudioStreams.Count > 0) { var audioStream = playlist.AudioStreams[0]; languageCode1 = audioStream.LanguageCode; audio1 = string.Format(CultureInfo.InvariantCulture, "{0} {1}", audioStream.CodecAltName, audioStream.ChannelDescription); if (audioStream.BitRate > 0) { audio1 += string.Format(CultureInfo.InvariantCulture, " {0}Kbps", (int)Math.Round((double)audioStream.BitRate / 1000)); } if (audioStream.SampleRate > 0 && audioStream.BitDepth > 0) { audio1 += string.Format(CultureInfo.InvariantCulture, " ({0}kHz/{1}-bit)", (int)Math.Round((double)audioStream.SampleRate / 1000), audioStream.BitDepth); } } var audio2 = ""; if (playlist.AudioStreams.Count > 1) { for (var i = 1; i < playlist.AudioStreams.Count; i++) { var audioStream = playlist.AudioStreams[i]; if (audioStream.LanguageCode == languageCode1 && audioStream.StreamType != TSStreamType.AC3_PLUS_SECONDARY_AUDIO && audioStream.StreamType != TSStreamType.DTS_HD_SECONDARY_AUDIO && !(audioStream.StreamType == TSStreamType.AC3_AUDIO && audioStream.ChannelCount == 2)) { audio2 = string.Format(CultureInfo.InvariantCulture, "{0} {1}", audioStream.CodecAltName, audioStream.ChannelDescription); if (audioStream.BitRate > 0) { audio2 += string.Format(CultureInfo.InvariantCulture, " {0}Kbps", (int)Math.Round((double)audioStream.BitRate / 1000)); } if (audioStream.SampleRate > 0 && audioStream.BitDepth > 0) { audio2 += string.Format(CultureInfo.InvariantCulture, " ({0}kHz/{1}-bit)", (int)Math.Round((double)audioStream.SampleRate / 1000), audioStream.BitDepth); } break; } } } report.Append("\r\n"); report.Append("********************\r\n"); report.Append("PLAYLIST: " + playlist.Name + "\r\n"); report.Append("********************\r\n"); report.Append("\r\n"); report.Append("<--- BEGIN FORUMS PASTE --->\r\n"); report.Append("[code]\r\n"); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-64}{1,-8}{2,-8}{3,-16}{4,-16}{5,-8}{6,-8}{7,-42}{8}\r\n", "", "", "", "", "", "Total", "Video", "", "")); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-64}{1,-8}{2,-8}{3,-16}{4,-16}{5,-8}{6,-8}{7,-42}{8}\r\n", "Title", "Codec", "Length", "Movie Size", "Disc Size", "Bitrate", "Bitrate", "Main Audio Track", "Secondary Audio Track")); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-64}{1,-8}{2,-8}{3,-16}{4,-16}{5,-8}{6,-8}{7,-42}{8}\r\n", "-----", "------", "-------", "--------------", "--------------", "-------", "-------", "------------------", "---------------------")); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-64}{1,-8}{2,-8}{3,-16}{4,-16}{5,-8}{6,-8}{7,-42}{8}\r\n", title, videoCodec, totalLengthShort, totalSize, discSize, totalBitrate, videoBitrate, audio1, audio2)); report.Append("[/code]\r\n"); report.Append("\r\n"); report.Append("[code]\r\n"); report.Append("\r\n"); report.Append("DISC INFO:\r\n"); report.Append("\r\n"); if (!string.IsNullOrEmpty(BDROM.DiscTitle)) { report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-16}{1}\r\n", "Disc Title:", BDROM.DiscTitle)); } report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-16}{1}\r\n", "Disc Label:", BDROM.VolumeLabel)); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-16}{1:N0} bytes\r\n", "Disc Size:", BDROM.Size)); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-16}{1}\r\n", "Protection:", protection)); if (extraFeatures.Count > 0) { report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-16}{1}\r\n", "Extras:", string.Join(", ", extraFeatures.ToArray()))); } /*report.Append(string.Format(CultureInfo.InvariantCulture, * "{0,-16}{1}\r\n", "BDInfo:", Application.ProductVersion);*/ report.Append("\r\n"); report.Append("PLAYLIST REPORT:\r\n"); report.Append("\r\n"); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-24}{1}\r\n", "Name:", title)); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-24}{1} (h:m:s.ms)\r\n", "Length:", totalLength)); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-24}{1:N0} bytes\r\n", "Size:", totalSize)); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-24}{1} Mbps\r\n", "Total Bitrate:", totalBitrate)); if (playlist.AngleCount > 0) { for (var angleIndex = 0; angleIndex < playlist.AngleCount; angleIndex++) { report.Append("\r\n"); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-24}{1} (h:m:s.ms) / {2} (h:m:s.ms)\r\n", string.Format(CultureInfo.InvariantCulture, "Angle {0} Length:", angleIndex + 1), angleLengths[angleIndex], angleTotalLengths[angleIndex])); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-24}{1:N0} bytes / {2:N0} bytes\r\n", string.Format(CultureInfo.InvariantCulture, "Angle {0} Size:", angleIndex + 1), angleSizes[angleIndex], angleTotalSizes[angleIndex])); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-24}{1} Mbps / {2} Mbps\r\n", string.Format(CultureInfo.InvariantCulture, "Angle {0} Total Bitrate:", angleIndex + 1), angleBitrates[angleIndex], angleTotalBitrates[angleIndex], angleIndex)); } report.Append("\r\n"); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-24}{1} (h:m:s.ms)\r\n", "All Angles Length:", totalAngleLength)); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-24}{1} bytes\r\n", "All Angles Size:", totalAngleSize)); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-24}{1} Mbps\r\n", "All Angles Bitrate:", totalAngleBitrate)); } /* * report.Append(string.Format( * "{0,-24}{1}\r\n", "Description:", ""); */ if (!string.IsNullOrEmpty(BDROM.DiscTitle)) { summary += string.Format(CultureInfo.InvariantCulture, "Disc Title: {0}\r\n", BDROM.DiscTitle); } summary += string.Format(CultureInfo.InvariantCulture, "Disc Label: {0}\r\n", BDROM.VolumeLabel); summary += string.Format(CultureInfo.InvariantCulture, "Disc Size: {0:N0} bytes\r\n", BDROM.Size); summary += string.Format(CultureInfo.InvariantCulture, "Protection: {0}\r\n", protection); summary += string.Format(CultureInfo.InvariantCulture, "Playlist: {0}\r\n", title); summary += string.Format(CultureInfo.InvariantCulture, "Size: {0:N0} bytes\r\n", totalSize); summary += string.Format(CultureInfo.InvariantCulture, "Length: {0}\r\n", totalLength); summary += string.Format(CultureInfo.InvariantCulture, "Total Bitrate: {0} Mbps\r\n", totalBitrate); if (playlist.HasHiddenTracks) { report.Append("\r\n(*) Indicates included stream hidden by this playlist.\r\n"); } if (playlist.VideoStreams.Count > 0) { report.Append("\r\n"); report.Append("VIDEO:\r\n"); report.Append("\r\n"); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-24}{1,-20}{2,-16}\r\n", "Codec", "Bitrate", "Description")); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-24}{1,-20}{2,-16}\r\n", "-----", "-------", "-----------")); foreach (var stream in playlist.SortedStreams) { if (!stream.IsVideoStream) { continue; } var streamName = stream.CodecName; if (stream.AngleIndex > 0) { streamName += string.Format(CultureInfo.InvariantCulture, " ({0})", stream.AngleIndex); } var streamBitrate = string.Format(CultureInfo.InvariantCulture, "{0:D}", (int)Math.Round((double)stream.BitRate / 1000)); if (stream.AngleIndex > 0) { streamBitrate += string.Format(CultureInfo.InvariantCulture, " ({0:D})", (int)Math.Round((double)stream.ActiveBitRate / 1000)); } streamBitrate += " kbps"; report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-24}{1,-20}{2,-16}\r\n", (stream.IsHidden ? "* " : "") + streamName, streamBitrate, stream.Description)); summary += string.Format(CultureInfo.InvariantCulture, (stream.IsHidden ? "* " : "") + "Video: {0} / {1} / {2}\r\n", streamName, streamBitrate, stream.Description); } } if (playlist.AudioStreams.Count > 0) { report.Append("\r\n"); report.Append("AUDIO:\r\n"); report.Append("\r\n"); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-32}{1,-16}{2,-16}{3,-16}\r\n", "Codec", "Language", "Bitrate", "Description")); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-32}{1,-16}{2,-16}{3,-16}\r\n", "-----", "--------", "-------", "-----------")); foreach (var stream in playlist.SortedStreams) { if (!stream.IsAudioStream) { continue; } var streamBitrate = string.Format(CultureInfo.InvariantCulture, "{0:D} kbps", (int)Math.Round((double)stream.BitRate / 1000)); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-32}{1,-16}{2,-16}{3,-16}\r\n", (stream.IsHidden ? "* " : "") + stream.CodecName, stream.LanguageName, streamBitrate, stream.Description)); summary += string.Format((stream.IsHidden ? "* " : "") + "Audio: {0} / {1} / {2}\r\n", stream.LanguageName, stream.CodecName, stream.Description); } } if (playlist.GraphicsStreams.Count > 0) { report.Append("\r\n"); report.Append("SUBTITLES:\r\n"); report.Append("\r\n"); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-32}{1,-16}{2,-16}{3,-16}\r\n", "Codec", "Language", "Bitrate", "Description")); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-32}{1,-16}{2,-16}{3,-16}\r\n", "-----", "--------", "-------", "-----------")); foreach (var stream in playlist.SortedStreams) { if (!stream.IsGraphicsStream) { continue; } var streamBitrate = string.Format(CultureInfo.InvariantCulture, "{0:F3} kbps", (double)stream.BitRate / 1000); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-32}{1,-16}{2,-16}{3,-16}\r\n", (stream.IsHidden ? "* " : "") + stream.CodecName, stream.LanguageName, streamBitrate, stream.Description)); summary += string.Format(CultureInfo.InvariantCulture, (stream.IsHidden ? "* " : "") + "Subtitle: {0} / {1}\r\n", stream.LanguageName, streamBitrate, stream.Description); } } if (playlist.TextStreams.Count > 0) { report.Append("\r\n"); report.Append("TEXT:\r\n"); report.Append("\r\n"); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-32}{1,-16}{2,-16}{3,-16}\r\n", "Codec", "Language", "Bitrate", "Description")); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-32}{1,-16}{2,-16}{3,-16}\r\n", "-----", "--------", "-------", "-----------")); foreach (var stream in playlist.SortedStreams) { if (!stream.IsTextStream) { continue; } var streamBitrate = string.Format(CultureInfo.InvariantCulture, "{0:F3} kbps", (double)stream.BitRate / 1000); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-32}{1,-16}{2,-16}{3,-16}\r\n", (stream.IsHidden ? "* " : "") + stream.CodecName, stream.LanguageName, streamBitrate, stream.Description)); } } report.Append("\r\n"); report.Append("FILES:\r\n"); report.Append("\r\n"); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-16}{1,-16}{2,-16}{3,-16}{4,-16}\r\n", "Name", "Time In", "Length", "Size", "Total Bitrate")); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-16}{1,-16}{2,-16}{3,-16}{4,-16}\r\n", "----", "-------", "------", "----", "-------------")); foreach (var clip in playlist.StreamClips) { var clipName = clip.DisplayName; if (clip.AngleIndex > 0) { clipName += string.Format(CultureInfo.InvariantCulture, " ({0})", clip.AngleIndex); } var clipSize = string.Format(CultureInfo.InvariantCulture, "{0:N0}", clip.PacketSize); var clipInSpan = new TimeSpan((long)(clip.RelativeTimeIn * 10000000)); var clipOutSpan = new TimeSpan((long)(clip.RelativeTimeOut * 10000000)); var clipLengthSpan = new TimeSpan((long)(clip.Length * 10000000)); var clipTimeIn = string.Format(CultureInfo.InvariantCulture, "{0:D1}:{1:D2}:{2:D2}.{3:D3}", clipInSpan.Hours, clipInSpan.Minutes, clipInSpan.Seconds, clipInSpan.Milliseconds); var clipLength = string.Format(CultureInfo.InvariantCulture, "{0:D1}:{1:D2}:{2:D2}.{3:D3}", clipLengthSpan.Hours, clipLengthSpan.Minutes, clipLengthSpan.Seconds, clipLengthSpan.Milliseconds); var clipBitrate = Math.Round((double)clip.PacketBitRate / 1000).ToString("N0", CultureInfo.InvariantCulture); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-16}{1,-16}{2,-16}{3,-16}{4,-16}\r\n", clipName, clipTimeIn, clipLength, clipSize, clipBitrate)); } report.Append("\r\n"); report.Append("CHAPTERS:\r\n"); report.Append("\r\n"); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-16}{1,-16}{2,-16}{3,-16}{4,-16}{5,-16}{6,-16}{7,-16}{8,-16}{9,-16}{10,-16}{11,-16}{12,-16}\r\n", "Number", "Time In", "Length", "Avg Video Rate", "Max 1-Sec Rate", "Max 1-Sec Time", "Max 5-Sec Rate", "Max 5-Sec Time", "Max 10Sec Rate", "Max 10Sec Time", "Avg Frame Size", "Max Frame Size", "Max Frame Time")); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-16}{1,-16}{2,-16}{3,-16}{4,-16}{5,-16}{6,-16}{7,-16}{8,-16}{9,-16}{10,-16}{11,-16}{12,-16}\r\n", "------", "-------", "------", "--------------", "--------------", "--------------", "--------------", "--------------", "--------------", "--------------", "--------------", "--------------", "--------------")); var window1Bits = new Queue <double>(); var window1Seconds = new Queue <double>(); double window1BitsSum = 0; double window1SecondsSum = 0; double window1PeakBitrate = 0; double window1PeakLocation = 0; var window5Bits = new Queue <double>(); var window5Seconds = new Queue <double>(); double window5BitsSum = 0; double window5SecondsSum = 0; double window5PeakBitrate = 0; double window5PeakLocation = 0; var window10Bits = new Queue <double>(); var window10Seconds = new Queue <double>(); double window10BitsSum = 0; double window10SecondsSum = 0; double window10PeakBitrate = 0; double window10PeakLocation = 0; double chapterPosition = 0; double chapterBits = 0; long chapterFrameCount = 0; double chapterSeconds = 0; double chapterMaxFrameSize = 0; double chapterMaxFrameLocation = 0; var diagPID = playlist.VideoStreams[0].PID; var chapterIndex = 0; var clipIndex = 0; var diagIndex = 0; while (chapterIndex < playlist.Chapters.Count) { TSStreamClip clip = null; TSStreamFile file = null; if (clipIndex < playlist.StreamClips.Count) { clip = playlist.StreamClips[clipIndex]; file = clip.StreamFile; } var chapterStart = playlist.Chapters[chapterIndex]; double chapterEnd; if (chapterIndex < playlist.Chapters.Count - 1) { chapterEnd = playlist.Chapters[chapterIndex + 1]; } else { chapterEnd = playlist.TotalLength; } var chapterLength = chapterEnd - chapterStart; List <TSStreamDiagnostics> diagList = null; if (clip != null && clip.AngleIndex == 0 && file != null && file.StreamDiagnostics.ContainsKey(diagPID)) { diagList = file.StreamDiagnostics[diagPID]; while (diagIndex < diagList.Count && chapterPosition < chapterEnd) { var diag = diagList[diagIndex++]; if (diag.Marker < clip.TimeIn) { continue; } chapterPosition = diag.Marker - clip.TimeIn + clip.RelativeTimeIn; var seconds = diag.Interval; var bits = diag.Bytes * 8.0; chapterBits += bits; chapterSeconds += seconds; if (diag.Tag != null) { chapterFrameCount++; } window1SecondsSum += seconds; window1Seconds.Enqueue(seconds); window1BitsSum += bits; window1Bits.Enqueue(bits); window5SecondsSum += diag.Interval; window5Seconds.Enqueue(diag.Interval); window5BitsSum += bits; window5Bits.Enqueue(bits); window10SecondsSum += seconds; window10Seconds.Enqueue(seconds); window10BitsSum += bits; window10Bits.Enqueue(bits); if (bits > chapterMaxFrameSize * 8) { chapterMaxFrameSize = bits / 8; chapterMaxFrameLocation = chapterPosition; } if (window1SecondsSum > 1.0) { var bitrate = window1BitsSum / window1SecondsSum; if (bitrate > window1PeakBitrate && chapterPosition - window1SecondsSum > 0) { window1PeakBitrate = bitrate; window1PeakLocation = chapterPosition - window1SecondsSum; } window1BitsSum -= window1Bits.Dequeue(); window1SecondsSum -= window1Seconds.Dequeue(); } if (window5SecondsSum > 5.0) { var bitrate = window5BitsSum / window5SecondsSum; if (bitrate > window5PeakBitrate && chapterPosition - window5SecondsSum > 0) { window5PeakBitrate = bitrate; window5PeakLocation = chapterPosition - window5SecondsSum; if (window5PeakLocation < 0) { window5PeakLocation = 0; window5PeakLocation = 0; } } window5BitsSum -= window5Bits.Dequeue(); window5SecondsSum -= window5Seconds.Dequeue(); } if (window10SecondsSum > 10.0) { var bitrate = window10BitsSum / window10SecondsSum; if (bitrate > window10PeakBitrate && chapterPosition - window10SecondsSum > 0) { window10PeakBitrate = bitrate; window10PeakLocation = chapterPosition - window10SecondsSum; } window10BitsSum -= window10Bits.Dequeue(); window10SecondsSum -= window10Seconds.Dequeue(); } } } if (diagList == null || diagIndex == diagList.Count) { if (clipIndex < playlist.StreamClips.Count) { clipIndex++; diagIndex = 0; } else { chapterPosition = chapterEnd; } } if (chapterPosition >= chapterEnd) { ++chapterIndex; var window1PeakSpan = new TimeSpan((long)(window1PeakLocation * 10000000)); var window5PeakSpan = new TimeSpan((long)(window5PeakLocation * 10000000)); var window10PeakSpan = new TimeSpan((long)(window10PeakLocation * 10000000)); var chapterMaxFrameSpan = new TimeSpan((long)(chapterMaxFrameLocation * 10000000)); var chapterStartSpan = new TimeSpan((long)(chapterStart * 10000000)); var chapterEndSpan = new TimeSpan((long)(chapterEnd * 10000000)); var chapterLengthSpan = new TimeSpan((long)(chapterLength * 10000000)); double chapterBitrate = 0; if (chapterLength > 0) { chapterBitrate = chapterBits / chapterLength; } double chapterAvgFrameSize = 0; if (chapterFrameCount > 0) { chapterAvgFrameSize = chapterBits / chapterFrameCount / 8; } report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-16}{1,-16}{2,-16}{3,-16}{4,-16}{5,-16}{6,-16}{7,-16}{8,-16}{9,-16}{10,-16}{11,-16}{12,-16}\r\n", chapterIndex, string.Format(CultureInfo.InvariantCulture, "{0:D1}:{1:D2}:{2:D2}.{3:D3}", chapterStartSpan.Hours, chapterStartSpan.Minutes, chapterStartSpan.Seconds, chapterStartSpan.Milliseconds), string.Format(CultureInfo.InvariantCulture, "{0:D1}:{1:D2}:{2:D2}.{3:D3}", chapterLengthSpan.Hours, chapterLengthSpan.Minutes, chapterLengthSpan.Seconds, chapterLengthSpan.Milliseconds), string.Format(CultureInfo.InvariantCulture, "{0:N0} kbps", Math.Round(chapterBitrate / 1000)), string.Format(CultureInfo.InvariantCulture, "{0:N0} kbps", Math.Round(window1PeakBitrate / 1000)), string.Format(CultureInfo.InvariantCulture, "{0:D2}:{1:D2}:{2:D2}.{3:D3}", window1PeakSpan.Hours, window1PeakSpan.Minutes, window1PeakSpan.Seconds, window1PeakSpan.Milliseconds), string.Format(CultureInfo.InvariantCulture, "{0:N0} kbps", Math.Round(window5PeakBitrate / 1000)), string.Format(CultureInfo.InvariantCulture, "{0:D2}:{1:D2}:{2:D2}.{3:D3}", window5PeakSpan.Hours, window5PeakSpan.Minutes, window5PeakSpan.Seconds, window5PeakSpan.Milliseconds), string.Format(CultureInfo.InvariantCulture, "{0:N0} kbps", Math.Round(window10PeakBitrate / 1000)), string.Format(CultureInfo.InvariantCulture, "{0:D2}:{1:D2}:{2:D2}.{3:D3}", window10PeakSpan.Hours, window10PeakSpan.Minutes, window10PeakSpan.Seconds, window10PeakSpan.Milliseconds), string.Format(CultureInfo.InvariantCulture, "{0:N0} bytes", chapterAvgFrameSize), string.Format(CultureInfo.InvariantCulture, "{0:N0} bytes", chapterMaxFrameSize), string.Format(CultureInfo.InvariantCulture, "{0:D2}:{1:D2}:{2:D2}.{3:D3}", chapterMaxFrameSpan.Hours, chapterMaxFrameSpan.Minutes, chapterMaxFrameSpan.Seconds, chapterMaxFrameSpan.Milliseconds))); window1Bits = new Queue <double>(); window1Seconds = new Queue <double>(); window1BitsSum = 0; window1SecondsSum = 0; window1PeakBitrate = 0; window1PeakLocation = 0; window5Bits = new Queue <double>(); window5Seconds = new Queue <double>(); window5BitsSum = 0; window5SecondsSum = 0; window5PeakBitrate = 0; window5PeakLocation = 0; window10Bits = new Queue <double>(); window10Seconds = new Queue <double>(); window10BitsSum = 0; window10SecondsSum = 0; window10PeakBitrate = 0; window10PeakLocation = 0; chapterBits = 0; chapterSeconds = 0; chapterFrameCount = 0; chapterMaxFrameSize = 0; chapterMaxFrameLocation = 0; } } if (BDInfoSettings.GenerateStreamDiagnostics) { report.Append("\r\n"); report.Append("STREAM DIAGNOSTICS:\r\n"); report.Append("\r\n"); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-16}{1,-16}{2,-16}{3,-16}{4,-24}{5,-24}{6,-24}{7,-16}{8,-16}\r\n", "File", "PID", "Type", "Codec", "Language", "Seconds", "Bitrate", "Bytes", "Packets")); report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-16}{1,-16}{2,-16}{3,-16}{4,-24}{5,-24}{6,-24}{7,-16}{8,-16}\r\n", "----", "---", "----", "-----", "--------", "--------------", "--------------", "-------------", "-----", "-------")); var reportedClips = new Dictionary <string, TSStreamClip>(); foreach (var clip in playlist.StreamClips) { if (clip.StreamFile == null) { continue; } if (reportedClips.ContainsKey(clip.Name)) { continue; } reportedClips[clip.Name] = clip; var clipName = clip.DisplayName; if (clip.AngleIndex > 0) { clipName += string.Format(CultureInfo.InvariantCulture, " ({0})", clip.AngleIndex); } foreach (var clipStream in clip.StreamFile.Streams.Values) { if (!playlist.Streams.ContainsKey(clipStream.PID)) { continue; } var playlistStream = playlist.Streams[clipStream.PID]; var clipBitRate = "0"; var clipSeconds = "0"; if (clip.StreamFile.Length > 0) { clipSeconds = clip.StreamFile.Length.ToString("F3", CultureInfo.InvariantCulture); clipBitRate = Math.Round((double)clipStream.PayloadBytes * 8 / clip.StreamFile.Length / 1000) .ToString("N0", CultureInfo.InvariantCulture); } var language = ""; if (!string.IsNullOrEmpty(playlistStream.LanguageCode)) { language = string.Format(CultureInfo.InvariantCulture, "{0} ({1})", playlistStream.LanguageCode, playlistStream.LanguageName); } report.Append(string.Format(CultureInfo.InvariantCulture, "{0,-16}{1,-16}{2,-16}{3,-16}{4,-24}{5,-24}{6,-24}{7,-16}{8,-16}\r\n", clipName, string.Format(CultureInfo.InvariantCulture, "{0} (0x{1:X})", clipStream.PID, clipStream.PID), string.Format(CultureInfo.InvariantCulture, "0x{0:X2}", (byte)clipStream.StreamType), clipStream.CodecShortName, language, clipSeconds, clipBitRate, clipStream.PayloadBytes.ToString("N0", CultureInfo.InvariantCulture), clipStream.PacketCount.ToString("N0", CultureInfo.InvariantCulture))); } } } report.Append("\r\n"); report.Append("[/code]\r\n"); report.Append("<---- END FORUMS PASTE ---->\r\n"); report.Append("\r\n"); if (BDInfoSettings.GenerateTextSummary) { report.Append("QUICK SUMMARY:\r\n\r\n"); report.Append(summary); report.Append("\r\n"); } } return(report.ToString()); }
public void Scan() { List <TSStreamClipFile> errorStreamClipFiles = new List <TSStreamClipFile>(); foreach (TSStreamClipFile streamClipFile in StreamClipFiles.Values) { try { streamClipFile.Scan(); } catch (Exception ex) { errorStreamClipFiles.Add(streamClipFile); if (StreamClipFileScanError != null) { if (StreamClipFileScanError(streamClipFile, ex)) { continue; } else { break; } } else { throw ex; } } } foreach (TSStreamFile streamFile in StreamFiles.Values) { string ssifName = Path.GetFileNameWithoutExtension(streamFile.Name) + ".SSIF"; if (InterleavedFiles.ContainsKey(ssifName)) { streamFile.InterleavedFile = InterleavedFiles[ssifName]; } } TSStreamFile[] streamFiles = new TSStreamFile[StreamFiles.Count]; StreamFiles.Values.CopyTo(streamFiles, 0); Array.Sort(streamFiles, CompareStreamFiles); List <TSPlaylistFile> errorPlaylistFiles = new List <TSPlaylistFile>(); foreach (TSPlaylistFile playlistFile in PlaylistFiles.Values) { try { playlistFile.Scan(StreamFiles, StreamClipFiles); } catch (Exception ex) { errorPlaylistFiles.Add(playlistFile); if (PlaylistFileScanError != null) { if (PlaylistFileScanError(playlistFile, ex)) { continue; } else { break; } } else { throw ex; } } } List <TSStreamFile> errorStreamFiles = new List <TSStreamFile>(); foreach (TSStreamFile streamFile in streamFiles) { try { List <TSPlaylistFile> playlists = new List <TSPlaylistFile>(); foreach (TSPlaylistFile playlist in PlaylistFiles.Values) { foreach (TSStreamClip streamClip in playlist.StreamClips) { if (streamClip.Name == streamFile.Name) { playlists.Add(playlist); break; } } } streamFile.Scan(playlists, false); } catch (Exception ex) { errorStreamFiles.Add(streamFile); if (StreamFileScanError != null) { if (StreamFileScanError(streamFile, ex)) { continue; } else { break; } } else { throw ex; } } } foreach (TSPlaylistFile playlistFile in PlaylistFiles.Values) { playlistFile.Initialize(); if (!Is50Hz) { int vidStreamCount = playlistFile.VideoStreams.Count; foreach (TSVideoStream videoStream in playlistFile.VideoStreams) { if (videoStream.FrameRate == TSFrameRate.FRAMERATE_25 || videoStream.FrameRate == TSFrameRate.FRAMERATE_50) { Is50Hz = true; } if (vidStreamCount > 1) { if ((videoStream.StreamType == TSStreamType.AVC_VIDEO && playlistFile.MVCBaseViewR) || (videoStream.StreamType == TSStreamType.MVC_VIDEO && !playlistFile.MVCBaseViewR)) { videoStream.BaseView = true; } else if (videoStream.StreamType == TSStreamType.AVC_VIDEO || videoStream.StreamType == TSStreamType.MVC_VIDEO) { videoStream.BaseView = false; } } } } } }
public void Scan() { List <TSStreamClipFile> errorStreamClipFiles = new List <TSStreamClipFile>(); foreach (TSStreamClipFile streamClipFile in StreamClipFiles.Values) { try { streamClipFile.Scan(); } catch (Exception ex) { errorStreamClipFiles.Add(streamClipFile); if (StreamClipFileScanError != null) { if (StreamClipFileScanError(streamClipFile, ex)) { continue; } else { break; } } else { throw ex; } } } foreach (TSStreamFile streamFile in StreamFiles.Values) { string ssifName = Path.GetFileNameWithoutExtension(streamFile.Name) + ".SSIF"; if (InterleavedFiles.ContainsKey(ssifName)) { streamFile.InterleavedFile = InterleavedFiles[ssifName]; } } TSStreamFile[] streamFiles = new TSStreamFile[StreamFiles.Count]; StreamFiles.Values.CopyTo(streamFiles, 0); Array.Sort(streamFiles, CompareStreamFiles); List <TSPlaylistFile> errorPlaylistFiles = new List <TSPlaylistFile>(); foreach (TSPlaylistFile playlistFile in PlaylistFiles.Values) { try { playlistFile.Scan(StreamFiles, StreamClipFiles); } catch (Exception ex) { errorPlaylistFiles.Add(playlistFile); if (PlaylistFileScanError != null) { if (PlaylistFileScanError(playlistFile, ex)) { continue; } else { break; } } else { throw ex; } } } List <TSStreamFile> errorStreamFiles = new List <TSStreamFile>(); foreach (TSStreamFile streamFile in streamFiles) { try { List <TSPlaylistFile> playlists = new List <TSPlaylistFile>(); foreach (TSPlaylistFile playlist in PlaylistFiles.Values) { foreach (TSStreamClip streamClip in playlist.StreamClips) { if (streamClip.Name == streamFile.Name) { playlists.Add(playlist); break; } } } streamFile.Scan(playlists, false); } catch (Exception ex) { errorStreamFiles.Add(streamFile); if (StreamFileScanError != null) { if (StreamFileScanError(streamFile, ex)) { continue; } else { break; } } else { throw ex; } } } foreach (TSPlaylistFile playlistFile in PlaylistFiles.Values) { playlistFile.Initialize(); } }
public void Scan( Dictionary <string, TSStreamFile> streamFiles, Dictionary <string, TSStreamClipFile> streamClipFiles) { Stream fileStream = null; BinaryReader fileReader = null; try { Streams.Clear(); StreamClips.Clear(); fileStream = File.OpenRead(FileInfo.FullName); fileReader = new BinaryReader(fileStream); byte[] data = new byte[fileStream.Length]; int dataLength = fileReader.Read(data, 0, data.Length); int pos = 0; FileType = ReadString(data, 8, ref pos); if (FileType != "MPLS0100" && FileType != "MPLS0200") { throw new Exception(string.Format( "Playlist {0} has an unknown file type {1}.", FileInfo.Name, FileType)); } int playlistOffset = ReadInt32(data, ref pos); int chaptersOffset = ReadInt32(data, ref pos); int extensionsOffset = ReadInt32(data, ref pos); pos = playlistOffset; int playlistLength = ReadInt32(data, ref pos); int playlistReserved = ReadInt16(data, ref pos); int itemCount = ReadInt16(data, ref pos); int subitemCount = ReadInt16(data, ref pos); var chapterClips = new List <TSStreamClip>(); for (int itemIndex = 0; itemIndex < itemCount; itemIndex++) { int itemStart = pos; int itemLength = ReadInt16(data, ref pos); string itemName = ReadString(data, 5, ref pos); string itemType = ReadString(data, 4, ref pos); TSStreamFile streamFile = null; string streamFileName = string.Format( "{0}.M2TS", itemName); if (streamFiles.ContainsKey(streamFileName)) { streamFile = streamFiles[streamFileName]; } if (streamFile == null) { // Error condition } TSStreamClipFile streamClipFile = null; string streamClipFileName = string.Format( "{0}.CLPI", itemName); if (streamClipFiles.ContainsKey(streamClipFileName)) { streamClipFile = streamClipFiles[streamClipFileName]; } if (streamClipFile == null) { throw new Exception(string.Format( "Playlist {0} referenced missing file {1}.", FileInfo.Name, streamFileName)); } pos += 1; int multiangle = (data[pos] >> 4) & 0x01; int condition = data[pos] & 0x0F; pos += 2; int inTime = ReadInt32(data, ref pos); if (inTime < 0) { inTime &= 0x7FFFFFFF; } double timeIn = (double)inTime / 45000; int outTime = ReadInt32(data, ref pos); if (outTime < 0) { outTime &= 0x7FFFFFFF; } double timeOut = (double)outTime / 45000; var streamClip = new TSStreamClip( streamFile, streamClipFile); streamClip.Name = streamFileName; //TODO streamClip.TimeIn = timeIn; streamClip.TimeOut = timeOut; streamClip.Length = streamClip.TimeOut - streamClip.TimeIn; streamClip.RelativeTimeIn = TotalLength; streamClip.RelativeTimeOut = streamClip.RelativeTimeIn + streamClip.Length; StreamClips.Add(streamClip); chapterClips.Add(streamClip); pos += 12; if (multiangle > 0) { int angles = data[pos]; pos += 2; for (int angle = 0; angle < angles - 1; angle++) { string angleName = ReadString(data, 5, ref pos); string angleType = ReadString(data, 4, ref pos); pos += 1; TSStreamFile angleFile = null; string angleFileName = string.Format( "{0}.M2TS", angleName); if (streamFiles.ContainsKey(angleFileName)) { angleFile = streamFiles[angleFileName]; } if (angleFile == null) { throw new Exception(string.Format( "Playlist {0} referenced missing angle file {1}.", FileInfo.Name, angleFileName)); } TSStreamClipFile angleClipFile = null; string angleClipFileName = string.Format( "{0}.CLPI", angleName); if (streamClipFiles.ContainsKey(angleClipFileName)) { angleClipFile = streamClipFiles[angleClipFileName]; } if (angleClipFile == null) { throw new Exception(string.Format( "Playlist {0} referenced missing angle file {1}.", FileInfo.Name, angleClipFileName)); } var angleClip = new TSStreamClip(angleFile, angleClipFile); angleClip.AngleIndex = angle + 1; angleClip.TimeIn = streamClip.TimeIn; angleClip.TimeOut = streamClip.TimeOut; angleClip.RelativeTimeIn = streamClip.RelativeTimeIn; angleClip.RelativeTimeOut = streamClip.RelativeTimeOut; angleClip.Length = streamClip.Length; StreamClips.Add(angleClip); } if (angles - 1 > AngleCount) { AngleCount = angles - 1; } } int streamInfoLength = ReadInt16(data, ref pos); pos += 2; int streamCountVideo = data[pos++]; int streamCountAudio = data[pos++]; int streamCountPG = data[pos++]; int streamCountIG = data[pos++]; int streamCountSecondaryAudio = data[pos++]; int streamCountSecondaryVideo = data[pos++]; int streamCountPIP = data[pos++]; pos += 5; #if DEBUG Debug.WriteLine(string.Format( "{0} : {1} -> V:{2} A:{3} PG:{4} IG:{5} 2A:{6} 2V:{7} PIP:{8}", Name, streamFileName, streamCountVideo, streamCountAudio, streamCountPG, streamCountIG, streamCountSecondaryAudio, streamCountSecondaryVideo, streamCountPIP)); #endif for (int i = 0; i < streamCountVideo; i++) { var stream = CreatePlaylistStream(data, ref pos); if (stream != null) { PlaylistStreams[stream.PID] = stream; } } for (int i = 0; i < streamCountAudio; i++) { var stream = CreatePlaylistStream(data, ref pos); if (stream != null) { PlaylistStreams[stream.PID] = stream; } } for (int i = 0; i < streamCountPG; i++) { var stream = CreatePlaylistStream(data, ref pos); if (stream != null) { PlaylistStreams[stream.PID] = stream; } } for (int i = 0; i < streamCountIG; i++) { var stream = CreatePlaylistStream(data, ref pos); if (stream != null) { PlaylistStreams[stream.PID] = stream; } } for (int i = 0; i < streamCountSecondaryAudio; i++) { var stream = CreatePlaylistStream(data, ref pos); if (stream != null) { PlaylistStreams[stream.PID] = stream; } pos += 2; } for (int i = 0; i < streamCountSecondaryVideo; i++) { var stream = CreatePlaylistStream(data, ref pos); if (stream != null) { PlaylistStreams[stream.PID] = stream; } pos += 6; } /* * TODO * * for (int i = 0; i < streamCountPIP; i++) * { * TSStream stream = CreatePlaylistStream(data, ref pos); * if (stream != null) PlaylistStreams[stream.PID] = stream; * } */ pos += itemLength - (pos - itemStart) + 2; } pos = chaptersOffset + 4; int chapterCount = ReadInt16(data, ref pos); for (int chapterIndex = 0; chapterIndex < chapterCount; chapterIndex++) { int chapterType = data[pos + 1]; if (chapterType == 1) { int streamFileIndex = ((int)data[pos + 2] << 8) + data[pos + 3]; long chapterTime = ((long)data[pos + 4] << 24) + ((long)data[pos + 5] << 16) + ((long)data[pos + 6] << 8) + ((long)data[pos + 7]); var streamClip = chapterClips[streamFileIndex]; double chapterSeconds = (double)chapterTime / 45000; double relativeSeconds = chapterSeconds - streamClip.TimeIn + streamClip.RelativeTimeIn; // TODO: Ignore short last chapter? if (TotalLength - relativeSeconds > 1.0) { streamClip.Chapters.Add(chapterSeconds); this.Chapters.Add(relativeSeconds); } } else { // TODO: Handle other chapter types? } pos += 14; } } finally { if (fileReader != null) { fileReader.Dispose(); } if (fileStream != null) { fileStream.Dispose(); } } }
public static int CompareStreamFiles( TSStreamFile x, TSStreamFile y) { // TODO: Use interleaved file sizes if ((x == null || x.FileInfo == null) && (y == null || y.FileInfo == null)) { return 0; } else if ((x == null || x.FileInfo == null) && (y != null && y.FileInfo != null)) { return 1; } else if ((x != null || x.FileInfo != null) && (y == null || y.FileInfo == null)) { return -1; } else { if (x.FileInfo.Length > y.FileInfo.Length) { return 1; } else if (y.FileInfo.Length > x.FileInfo.Length) { return -1; } else { return 0; } } }
protected bool BDROM_StreamFileScanError(TSStreamFile streamFile, Exception ex) { logger.Debug("Stream File Scan Error"); scanfailed = true; return false; }
public BDROM Scan(CancellationToken cancellationToken) { var numStreamClipFiles = StreamClipFiles.Count; var numPlaylists = PlaylistFiles.Count; var numStreamFiles = StreamFiles.Count; var numFilesOverall = numStreamClipFiles + numPlaylists + numStreamFiles; var curStreamClipFile = 0; var curPlaylist = 0; var curStreamFile = 0; var curFileOverall = 0; var completedStreamClipFiles = 0; var completedPlaylists = 0; var completedStreamFiles = 0; var completedFilesOverall = 0; List <TSStreamClipFile> errorStreamClipFiles = new List <TSStreamClipFile>(); foreach (TSStreamClipFile streamClipFile in StreamClipFiles.Values) { if (cancellationToken.IsCancellationRequested) { return(this); } try { ReportScanProgress("stream clip", streamClipFile.Name, 1, ++curStreamClipFile, numStreamClipFiles, completedStreamClipFiles, ++curFileOverall, numFilesOverall, completedFilesOverall); streamClipFile.Scan(); ReportScanProgress("stream clip", streamClipFile.Name, 1, curStreamClipFile, numStreamClipFiles, ++completedStreamClipFiles, curFileOverall, numFilesOverall, ++completedFilesOverall); } catch (Exception ex) { errorStreamClipFiles.Add(streamClipFile); if (StreamClipFileScanError != null) { if (StreamClipFileScanError(streamClipFile, ex)) { continue; } else { break; } } else { throw; } } } // TODO: Report progress foreach (TSStreamFile streamFile in StreamFiles.Values) { string ssifName = Path.GetFileNameWithoutExtension(streamFile.Name) + ".SSIF"; if (InterleavedFiles.ContainsKey(ssifName)) { streamFile.InterleavedFile = InterleavedFiles[ssifName]; } } TSStreamFile[] streamFiles = new TSStreamFile[StreamFiles.Count]; StreamFiles.Values.CopyTo(streamFiles, 0); Array.Sort(streamFiles, CompareStreamFiles); List <TSPlaylistFile> errorPlaylistFiles = new List <TSPlaylistFile>(); foreach (TSPlaylistFile playlistFile in PlaylistFiles.Values) { if (cancellationToken.IsCancellationRequested) { return(this); } try { ReportScanProgress("playlist", playlistFile.Name, 2, ++curPlaylist, numPlaylists, completedPlaylists, ++curFileOverall, numFilesOverall, completedFilesOverall); playlistFile.Scan(StreamFiles, StreamClipFiles); ReportScanProgress("playlist", playlistFile.Name, 2, curPlaylist, numPlaylists, ++completedPlaylists, curFileOverall, numFilesOverall, ++completedFilesOverall); } catch (Exception ex) { errorPlaylistFiles.Add(playlistFile); if (PlaylistFileScanError != null) { if (PlaylistFileScanError(playlistFile, ex)) { continue; } else { break; } } else { throw; } } } List <TSStreamFile> errorStreamFiles = new List <TSStreamFile>(); foreach (TSStreamFile streamFile in streamFiles) { if (cancellationToken.IsCancellationRequested) { return(this); } try { List <TSPlaylistFile> playlists = new List <TSPlaylistFile>(); foreach (TSPlaylistFile playlist in PlaylistFiles.Values) { foreach (TSStreamClip streamClip in playlist.StreamClips) { if (streamClip.Name == streamFile.Name) { playlists.Add(playlist); break; } } } ReportScanProgress("stream", streamFile.Name, 3, ++curStreamFile, numStreamFiles, completedStreamFiles, ++curFileOverall, numFilesOverall, completedFilesOverall); streamFile.Scan(playlists, false); ReportScanProgress("stream", streamFile.Name, 3, curStreamFile, numStreamFiles, ++completedStreamFiles, curFileOverall, numFilesOverall, ++completedFilesOverall); } catch (Exception ex) { errorStreamFiles.Add(streamFile); if (StreamFileScanError != null) { if (StreamFileScanError(streamFile, ex)) { continue; } else { break; } } else { throw; } } } foreach (TSPlaylistFile playlistFile in PlaylistFiles.Values) { if (cancellationToken.IsCancellationRequested) { return(this); } playlistFile.Initialize(); if (!Is50Hz) { foreach (TSVideoStream videoStream in playlistFile.VideoStreams) { if (videoStream.FrameRate == TSFrameRate.FRAMERATE_25 || videoStream.FrameRate == TSFrameRate.FRAMERATE_50) { Is50Hz = true; } } } } return(this); }
public void Scan() { List<TSStreamClipFile> errorStreamClipFiles = new List<TSStreamClipFile>(); foreach (TSStreamClipFile streamClipFile in StreamClipFiles.Values) { try { streamClipFile.Scan(); } catch (Exception ex) { errorStreamClipFiles.Add(streamClipFile); if (StreamClipFileScanError != null) { if (StreamClipFileScanError(streamClipFile, ex)) continue; break; } throw; } } foreach (TSStreamFile streamFile in StreamFiles.Values) { string ssifName = Path.GetFileNameWithoutExtension(streamFile.Name) + ".SSIF"; if (InterleavedFiles.ContainsKey(ssifName)) streamFile.InterleavedFile = InterleavedFiles[ssifName]; } TSStreamFile[] streamFiles = new TSStreamFile[StreamFiles.Count]; StreamFiles.Values.CopyTo(streamFiles, 0); Array.Sort(streamFiles, CompareStreamFiles); List<TSPlaylistFile> errorPlaylistFiles = new List<TSPlaylistFile>(); foreach (TSPlaylistFile playlistFile in PlaylistFiles.Values) { try { playlistFile.Scan(StreamFiles, StreamClipFiles); } catch (Exception ex) { errorPlaylistFiles.Add(playlistFile); if (PlaylistFileScanError != null) { if (PlaylistFileScanError(playlistFile, ex)) continue; break; } throw; } } List<TSStreamFile> errorStreamFiles = new List<TSStreamFile>(); foreach (TSStreamFile streamFile in streamFiles) { try { List<TSPlaylistFile> playlists = new List<TSPlaylistFile>(); foreach (TSPlaylistFile playlist in PlaylistFiles.Values) foreach (TSStreamClip streamClip in playlist.StreamClips) if (streamClip.Name == streamFile.Name) { playlists.Add(playlist); break; } streamFile.Scan(playlists, false); } catch (Exception ex) { errorStreamFiles.Add(streamFile); if (StreamFileScanError != null) { if (StreamFileScanError(streamFile, ex)) continue; break; } throw; } } foreach (TSPlaylistFile playlistFile in PlaylistFiles.Values) playlistFile.Initialize(); }
public void Scan() { List<TSStreamClipFile> errorStreamClipFiles = new List<TSStreamClipFile>(); foreach (TSStreamClipFile streamClipFile in StreamClipFiles.Values) { try { streamClipFile.Scan(); } catch (Exception ex) { errorStreamClipFiles.Add(streamClipFile); if (StreamClipFileScanError != null) { if (StreamClipFileScanError(streamClipFile, ex)) { continue; } else { break; } } else throw ex; } } foreach (TSStreamFile streamFile in StreamFiles.Values) { string ssifName = Path.GetFileNameWithoutExtension(streamFile.Name) + ".SSIF"; if (InterleavedFiles.ContainsKey(ssifName)) { streamFile.InterleavedFile = InterleavedFiles[ssifName]; } } TSStreamFile[] streamFiles = new TSStreamFile[StreamFiles.Count]; StreamFiles.Values.CopyTo(streamFiles, 0); Array.Sort(streamFiles, CompareStreamFiles); List<TSPlaylistFile> errorPlaylistFiles = new List<TSPlaylistFile>(); foreach (TSPlaylistFile playlistFile in PlaylistFiles.Values) { try { playlistFile.Scan(StreamFiles, StreamClipFiles); } catch (Exception ex) { errorPlaylistFiles.Add(playlistFile); if (PlaylistFileScanError != null) { if (PlaylistFileScanError(playlistFile, ex)) { continue; } else { break; } } else throw ex; } } List<TSStreamFile> errorStreamFiles = new List<TSStreamFile>(); foreach (TSStreamFile streamFile in streamFiles) { try { List<TSPlaylistFile> playlists = new List<TSPlaylistFile>(); foreach (TSPlaylistFile playlist in PlaylistFiles.Values) { foreach (TSStreamClip streamClip in playlist.StreamClips) { if (streamClip.Name == streamFile.Name) { playlists.Add(playlist); break; } } } streamFile.Scan(playlists, false); } catch (Exception ex) { errorStreamFiles.Add(streamFile); if (StreamFileScanError != null) { if (StreamFileScanError(streamFile, ex)) { continue; } else { break; } } else throw ex; } } foreach (TSPlaylistFile playlistFile in PlaylistFiles.Values) { playlistFile.Initialize(); if (!Is50Hz) { foreach (TSVideoStream videoStream in playlistFile.VideoStreams) { if (videoStream.FrameRate == TSFrameRate.FRAMERATE_25 || videoStream.FrameRate == TSFrameRate.FRAMERATE_50) { Is50Hz = true; } } } } }
public static int CompareStreamFiles(TSStreamFile x, TSStreamFile y) { // TODO: Use interleaved file sizes if ((x == null || x.FileInfo == null) && (y == null || y.FileInfo == null)) return 0; if ((x == null || x.FileInfo == null)) return 1; if ((y == null || y.FileInfo == null)) return -1; if (x.FileInfo.Length > y.FileInfo.Length) return 1; if (y.FileInfo.Length > x.FileInfo.Length) return -1; return 0; }
// not used anymore, but still there ;) private void SetRefreshRateBDold() { if (!_changeRefreshRate) { return; } Log.Info("Blu-Ray Player Launcher: SetRefreshRate for BDs"); if (_driveLetter == null) { Log.Error("Blu-Ray Player Launcher: SetRefreshRate - drive letter not assigned!"); return; } FileInfo[] files = null; double fps = -1; try { DirectoryInfo dir = new DirectoryInfo(_driveLetter + "\\BDMV\\PLAYLIST"); PlaylistFiles.Clear(); StreamFiles.Clear(); StreamClipFiles.Clear(); files = dir.GetFiles("*.MPLS"); foreach (FileInfo file in files) { TSPlaylistFile playlistFile = new TSPlaylistFile(file); PlaylistFiles.Add(file.Name.ToUpper(), playlistFile); //Log.Info("Blu-Ray Player Launcher: MPLS - {0} {1}", file.Name, playlistFile.TotalSize); } dir = new DirectoryInfo(_driveLetter + "\\BDMV\\STREAM"); files = dir.GetFiles("*.M2TS"); foreach (FileInfo file in files) { TSStreamFile streamFile = new TSStreamFile(file); StreamFiles.Add(file.Name.ToUpper(), streamFile); } dir = new DirectoryInfo(_driveLetter + "\\BDMV\\CLIPINF"); files = dir.GetFiles("*.CLPI"); foreach (FileInfo file in files) { TSStreamClipFile streamClipFile = new TSStreamClipFile(file); StreamClipFiles.Add(file.Name.ToUpper(), streamClipFile); } foreach (TSStreamClipFile streamClipFile in StreamClipFiles.Values) { streamClipFile.Scan(); } foreach (TSStreamFile streamFile in StreamFiles.Values) { streamFile.Scan(null, false); } double maxLenght = 0; foreach (TSPlaylistFile playlistFile in PlaylistFiles.Values) { playlistFile.Scan(StreamFiles, StreamClipFiles); Log.Info("Blu-Ray Player Launcher: total size - {0} - {1}", playlistFile.TotalLength, playlistFile.VideoStreams[0].FrameRate.ToString()); if (maxLenght < playlistFile.TotalLength) { // find the largest movie clip, might not work with seamless branching movies... maxLenght = playlistFile.TotalLength; switch (playlistFile.VideoStreams[0].FrameRate) { case TSFrameRate.FRAMERATE_23_976: fps = 23.976; break; case TSFrameRate.FRAMERATE_24: fps = 24; break; case TSFrameRate.FRAMERATE_25: fps = 25; break; case TSFrameRate.FRAMERATE_29_97: fps = 29.97; break; case TSFrameRate.FRAMERATE_50: fps = 50; break; case TSFrameRate.FRAMERATE_59_94: fps = 59.94; break; } } playlistFile.ClearBitrates(); } } catch (Exception e) { Log.Error("Blu-Ray Player Launcher: SetRefreshRate - failed to get refresh rate from disk!"); Log.Error("Blu-Ray Player Launcher: SetRefreshRate - exception {0}", e); return; } try { Log.Info("Blu-Ray Player Launcher: calling SetRefreshRateBasedOnFPS() - {0}Hz", fps); RefreshRateChanger.SetRefreshRateBasedOnFPS(fps, "", RefreshRateChanger.MediaType.Video); _refreshRateChangeSuccessful = true; } catch (Exception e) { Log.Error("Blu-Ray Player Launcher:SetRefreshRate - exception {0}", e); } }
public void Scan() { var errorStreamClipFiles = new List <TSStreamClipFile>(); foreach (var streamClipFile in StreamClipFiles.Values) { try { streamClipFile.Scan(); } catch (Exception ex) { errorStreamClipFiles.Add(streamClipFile); if (StreamClipFileScanError != null) { if (StreamClipFileScanError(streamClipFile, ex)) { continue; } else { break; } } else { throw; } } } foreach (var streamFile in StreamFiles.Values) { string ssifName = Path.GetFileNameWithoutExtension(streamFile.Name) + ".SSIF"; if (InterleavedFiles.ContainsKey(ssifName)) { streamFile.InterleavedFile = InterleavedFiles[ssifName]; } } TSStreamFile[] streamFiles = new TSStreamFile[StreamFiles.Count]; StreamFiles.Values.CopyTo(streamFiles, 0); Array.Sort(streamFiles, CompareStreamFiles); var errorPlaylistFiles = new List <TSPlaylistFile>(); foreach (var playlistFile in PlaylistFiles.Values) { try { playlistFile.Scan(StreamFiles, StreamClipFiles); } catch (Exception ex) { errorPlaylistFiles.Add(playlistFile); if (PlaylistFileScanError != null) { if (PlaylistFileScanError(playlistFile, ex)) { continue; } else { break; } } else { throw; } } } var errorStreamFiles = new List <TSStreamFile>(); foreach (var streamFile in streamFiles) { try { var playlists = new List <TSPlaylistFile>(); foreach (var playlist in PlaylistFiles.Values) { foreach (var streamClip in playlist.StreamClips) { if (streamClip.Name == streamFile.Name) { playlists.Add(playlist); break; } } } streamFile.Scan(playlists, false); } catch (Exception ex) { errorStreamFiles.Add(streamFile); if (StreamFileScanError != null) { if (StreamFileScanError(streamFile, ex)) { continue; } else { break; } } else { throw; } } } foreach (var playlistFile in PlaylistFiles.Values) { playlistFile.Initialize(); if (!Is50Hz) { foreach (var videoStream in playlistFile.VideoStreams) { if (videoStream.FrameRate == TSFrameRate.FRAMERATE_25 || videoStream.FrameRate == TSFrameRate.FRAMERATE_50) { Is50Hz = true; } } } } }
public BDROM Scan(CancellationToken cancellationToken) { var numStreamClipFiles = StreamClipFiles.Count; var numPlaylists = PlaylistFiles.Count; var numStreamFiles = StreamFiles.Count; var numFilesOverall = numStreamClipFiles + numPlaylists + numStreamFiles; var curStreamClipFile = 0; var curPlaylist = 0; var curStreamFile = 0; var curFileOverall = 0; var completedStreamClipFiles = 0; var completedPlaylists = 0; var completedStreamFiles = 0; var completedFilesOverall = 0; List<TSStreamClipFile> errorStreamClipFiles = new List<TSStreamClipFile>(); foreach (TSStreamClipFile streamClipFile in StreamClipFiles.Values) { if (cancellationToken.IsCancellationRequested) return this; try { ReportScanProgress("stream clip", streamClipFile.Name, 1, ++curStreamClipFile, numStreamClipFiles, completedStreamClipFiles, ++curFileOverall, numFilesOverall, completedFilesOverall); streamClipFile.Scan(); ReportScanProgress("stream clip", streamClipFile.Name, 1, curStreamClipFile, numStreamClipFiles, ++completedStreamClipFiles, curFileOverall, numFilesOverall, ++completedFilesOverall); } catch (Exception ex) { errorStreamClipFiles.Add(streamClipFile); if (StreamClipFileScanError != null) { if (StreamClipFileScanError(streamClipFile, ex)) { continue; } else { break; } } else throw; } } // TODO: Report progress foreach (TSStreamFile streamFile in StreamFiles.Values) { string ssifName = Path.GetFileNameWithoutExtension(streamFile.Name) + ".SSIF"; if (InterleavedFiles.ContainsKey(ssifName)) { streamFile.InterleavedFile = InterleavedFiles[ssifName]; } } TSStreamFile[] streamFiles = new TSStreamFile[StreamFiles.Count]; StreamFiles.Values.CopyTo(streamFiles, 0); Array.Sort(streamFiles, CompareStreamFiles); List<TSPlaylistFile> errorPlaylistFiles = new List<TSPlaylistFile>(); foreach (TSPlaylistFile playlistFile in PlaylistFiles.Values) { if (cancellationToken.IsCancellationRequested) return this; try { ReportScanProgress("playlist", playlistFile.Name, 2, ++curPlaylist, numPlaylists, completedPlaylists, ++curFileOverall, numFilesOverall, completedFilesOverall); playlistFile.Scan(StreamFiles, StreamClipFiles); ReportScanProgress("playlist", playlistFile.Name, 2, curPlaylist, numPlaylists, ++completedPlaylists, curFileOverall, numFilesOverall, ++completedFilesOverall); } catch (Exception ex) { errorPlaylistFiles.Add(playlistFile); if (PlaylistFileScanError != null) { if (PlaylistFileScanError(playlistFile, ex)) { continue; } else { break; } } else throw; } } List<TSStreamFile> errorStreamFiles = new List<TSStreamFile>(); foreach (TSStreamFile streamFile in streamFiles) { if (cancellationToken.IsCancellationRequested) return this; try { List<TSPlaylistFile> playlists = new List<TSPlaylistFile>(); foreach (TSPlaylistFile playlist in PlaylistFiles.Values) { foreach (TSStreamClip streamClip in playlist.StreamClips) { if (streamClip.Name == streamFile.Name) { playlists.Add(playlist); break; } } } ReportScanProgress("stream", streamFile.Name, 3, ++curStreamFile, numStreamFiles, completedStreamFiles, ++curFileOverall, numFilesOverall, completedFilesOverall); streamFile.Scan(playlists, false); ReportScanProgress("stream", streamFile.Name, 3, curStreamFile, numStreamFiles, ++completedStreamFiles, curFileOverall, numFilesOverall, ++completedFilesOverall); } catch (Exception ex) { errorStreamFiles.Add(streamFile); if (StreamFileScanError != null) { if (StreamFileScanError(streamFile, ex)) { continue; } else { break; } } else throw; } } foreach (TSPlaylistFile playlistFile in PlaylistFiles.Values) { if (cancellationToken.IsCancellationRequested) return this; playlistFile.Initialize(); if (!Is50Hz) { foreach (TSVideoStream videoStream in playlistFile.VideoStreams) { if (videoStream.FrameRate == TSFrameRate.FRAMERATE_25 || videoStream.FrameRate == TSFrameRate.FRAMERATE_50) { Is50Hz = true; } } } } return this; }
protected bool BDROM_StreamFileScanError(TSStreamFile streamFile, Exception ex) { DialogResult result = MessageBox.Show(string.Format( "An error occurred while scanning the stream file {0}.\n\nThe disc may be copy-protected or damaged.\n\nDo you want to continue scanning the stream files?", streamFile.Name), "BDInfo Scan Error", MessageBoxButtons.YesNo); if (result == DialogResult.Yes) return true; else return false; }
protected bool BDROM_StreamFileScanError(TSStreamFile streamFile, Exception ex) { System.Console.WriteLine(string.Format( "An error occurred while scanning the stream file {0}.\n\nThe disc may be copy-protected or damaged.\n\nDo you want to continue scanning the stream files?", streamFile.Name)); return GetYorNdefaultY(); }