public TSPlaylistFile(
BDROM bdrom,
string name,
List<TSStreamClip> clips)
{
BDROM = bdrom;
Name = name;
IsCustom = true;
foreach (TSStreamClip clip in clips)
{
TSStreamClip newClip = new TSStreamClip(
clip.StreamFile, clip.StreamClipFile);
newClip.Name = clip.Name;
newClip.TimeIn = clip.TimeIn;
newClip.TimeOut = clip.TimeOut;
newClip.Length = newClip.TimeOut - newClip.TimeIn;
newClip.RelativeTimeIn = TotalLength;
newClip.RelativeTimeOut = newClip.RelativeTimeIn + newClip.Length;
newClip.AngleIndex = clip.AngleIndex;
newClip.Chapters.Add(clip.TimeIn);
StreamClips.Add(newClip);
if (newClip.AngleIndex > AngleCount)
{
AngleCount = newClip.AngleIndex;
}
if (newClip.AngleIndex == 0)
{
Chapters.Add(newClip.RelativeTimeIn);
}
}
LoadStreamClips();
IsInitialized = true;
}
public TSPlaylistFile(BDROM bdrom,
FileSystemMetadata fileInfo)
{
BDROM = bdrom;
FileInfo = fileInfo;
Name = fileInfo.Name.ToUpper();
}
public Disc ReadBDROM(CancellationToken cancellationToken, string bdromPath)
{
if (cancellationToken.IsCancellationRequested)
{
return(null);
}
Host.ReportProgress(this, 0.0, "Scanning BD-ROM...");
var bdrom = new BDInfo.BDROM(bdromPath);
bdrom.ScanProgress += BDROMOnScanProgress;
bdrom.Scan(cancellationToken);
if (cancellationToken.IsCancellationRequested)
{
return(null);
}
Host.ReportProgress(this, 99.0, "Transforming BDInfo structure into BDHero structure...");
var disc = DiscTransformer.Transform(bdrom);
Host.ReportProgress(this, 100.0, "Finished scanning BD-ROM");
return(disc);
}
public TSPlaylistFile(BDROM bdrom,
string name,
List <TSStreamClip> clips, IFileSystem fileSystem)
{
BDROM = bdrom;
Name = name;
_fileSystem = fileSystem;
IsCustom = true;
foreach (var clip in clips)
{
var newClip = new TSStreamClip(
clip.StreamFile, clip.StreamClipFile);
newClip.Name = clip.Name;
newClip.TimeIn = clip.TimeIn;
newClip.TimeOut = clip.TimeOut;
newClip.Length = newClip.TimeOut - newClip.TimeIn;
newClip.RelativeTimeIn = TotalLength;
newClip.RelativeTimeOut = newClip.RelativeTimeIn + newClip.Length;
newClip.AngleIndex = clip.AngleIndex;
newClip.Chapters.Add(clip.TimeIn);
StreamClips.Add(newClip);
if (newClip.AngleIndex > AngleCount)
{
AngleCount = newClip.AngleIndex;
}
if (newClip.AngleIndex == 0)
{
Chapters.Add(newClip.RelativeTimeIn);
}
}
LoadStreamClips();
IsInitialized = true;
}
public TSPlaylistFile(
BDROM bdrom,
FileInfo fileInfo)
{
BDROM = bdrom;
FileInfo = fileInfo;
Name = fileInfo.Name.ToUpper();
}
public TSPlaylistFile(
BDROM bdrom,
FileInfo fileInfo)
{
_settings = ServiceRegistration.Get<ISettingsManager>().Load<BDInfoSettings>() ?? new BDInfoSettings();
BDROM = bdrom;
FileInfo = fileInfo;
Name = fileInfo.Name.ToUpper();
}
public TSPlaylistFile(
BDROM bdrom,
FileInfo fileInfo)
{
_settings = ServiceRegistration.Get <ISettingsManager>().Load <BDInfoSettings>() ?? new BDInfoSettings();
BDROM = bdrom;
FileInfo = fileInfo;
Name = fileInfo.Name.ToUpper();
}
public TSPlaylistFile(
BDROM bdrom,
FileInfo fileInfo)
{
BDROM = bdrom;
FileInfo = fileInfo;
DFileInfo = null;
CdReader = null;
Name = fileInfo.Name.ToUpper();
}
public TSPlaylistFile(
BDROM bdrom,
FileSystemMetadata fileInfo, IFileSystem fileSystem, ITextEncoding textEncoding)
{
BDROM = bdrom;
FileInfo = fileInfo;
_fileSystem = fileSystem;
_textEncoding = textEncoding;
Name = fileInfo.Name.ToUpper();
}
//private BackgroundWorker InitBDROMWorker = null;
public void InitBDROM(string path)
{
System.Console.WriteLine("Please wait while we scan the disc...");
try
{
BDROM = new BDROM(path);
BDROM.StreamClipFileScanError += new BDROM.OnStreamClipFileScanError(BDROM_StreamClipFileScanError);
BDROM.StreamFileScanError += new BDROM.OnStreamFileScanError(BDROM_StreamFileScanError);
BDROM.PlaylistFileScanError += new BDROM.OnPlaylistFileScanError(BDROM_PlaylistFileScanError);
BDROM.Scan();
//System.Console.WriteLine(BDROM.DirectoryRoot.FullName);
System.Console.WriteLine(string.Format("Detected BDMV Folder Full Path: {0}", BDROM.DirectoryBDMV.FullName));
System.Console.WriteLine(string.Format("Disc Title: ({0})", BDROM.VolumeLabel));
List <string> features = new List <string>();
if (BDROM.Is50Hz)
{
features.Add("50Hz Content");
}
if (BDROM.IsBDPlus)
{
features.Add("BD+ Copy Protection");
}
if (BDROM.IsBDJava)
{
features.Add("BD-Java");
}
if (BDROM.Is3D)
{
features.Add("Blu-ray 3D");
}
if (BDROM.IsDBOX)
{
features.Add("D-BOX Motion Code");
}
if (BDROM.IsPSP)
{
features.Add("PSP Digital Copy");
}
if (features.Count > 0)
{
System.Console.WriteLine("Detected Features: " + string.Join(", ", features.ToArray()));
}
System.Console.WriteLine(string.Format("Disc Size: {0:N0} bytes{1}", BDROM.Size, Environment.NewLine));
}
catch (Exception ex)
{
throw ex;
}
}
public FormPlaylist(string name, BDROM bdrom, OnCustomPlaylistFinished func)
{
InitializeComponent();
textBoxName.Text = name;
BDROM = bdrom;
OnFinished = func;
PlaylistColumnSorter = new ListViewColumnSorter();
listViewPlaylistFiles.ListViewItemSorter = PlaylistColumnSorter;
}
public FormPlaylist(string name, BDROM bdrom, OnCustomPlaylistFinished func)
{
InitializeComponent();
textBoxName.Text = name;
BDROM = bdrom;
OnFinished = func;
PlaylistColumnSorter = new ListViewColumnSorter();
listViewPlaylistFiles.ListViewItemSorter = PlaylistColumnSorter;
}
public TSPlaylistFile(
BDROM bdrom,
DiscFileInfo fileInfo,
UdfReader reader)
{
BDROM = bdrom;
DFileInfo = fileInfo;
FileInfo = null;
CdReader = reader;
Name = fileInfo.Name.ToUpper();
}
public void InitBDROMWork(
object sender,
DoWorkEventArgs e
)
{
try {
BDROM = new BDROM((string)e.Argument);
// BDROM.StreamClipFileScanError += new BDROM.OnStreamClipFileScanError(BDROM_StreamClipFileScanError);
// BDROM.StreamFileScanError += new BDROM.OnStreamFileScanError(BDROM_StreamFileScanError);
// BDROM.PlaylistFileScanError += new BDROM.OnPlaylistFileScanError(BDROM_PlaylistFileScanError);
BDROM.Scan();
e.Result = null;
}
catch (Exception ex) {
e.Result = ex;
}
}
public Disc ReadBDROM(CancellationToken cancellationToken, string bdromPath)
{
if (cancellationToken.IsCancellationRequested)
return null;
Host.ReportProgress(this, 0.0, "Scanning BD-ROM...");
var bdrom = new BDInfo.BDROM(bdromPath);
bdrom.ScanProgress += BDROMOnScanProgress;
bdrom.Scan(cancellationToken);
if (cancellationToken.IsCancellationRequested)
return null;
Host.ReportProgress(this, 99.0, "Transforming BDInfo structure into BDHero structure...");
var disc = DiscTransformer.Transform(bdrom);
Host.ReportProgress(this, 100.0, "Finished scanning BD-ROM");
return disc;
}
private BDInfo.BDROM ScanBDROM(CancellationToken cancellationToken, string bdromPath)
{
try
{
var bdrom = new BDInfo.BDROM(bdromPath);
bdrom.ScanProgress += BDROMOnScanProgress;
bdrom.PlaylistFileScanError += BDROMOnPlaylistFileScanError;
bdrom.StreamFileScanError += BDROMOnStreamFileScanError;
bdrom.StreamClipFileScanError += BDROMOnStreamClipFileScanError;
bdrom.Scan(cancellationToken);
return(bdrom);
}
catch (Exception e)
{
if (e is ArgumentException ||
e is UnauthorizedAccessException ||
e is IOException)
{
throw new ID10TException(e.Message, e);
}
throw;
}
}
public TSPlaylistFile(
BDROM bdrom,
string name,
List <TSStreamClip> clips)
{
_settings = ServiceRegistration.Get <ISettingsManager>().Load <BDInfoSettings>() ?? new BDInfoSettings();
BDROM = bdrom;
Name = name;
IsCustom = true;
foreach (TSStreamClip clip in clips)
{
TSStreamClip newClip = new TSStreamClip(
clip.StreamFile, clip.StreamClipFile);
newClip.Name = clip.Name;
newClip.TimeIn = clip.TimeIn;
newClip.TimeOut = clip.TimeOut;
newClip.Length = newClip.TimeOut - newClip.TimeIn;
newClip.RelativeTimeIn = TotalLength;
newClip.RelativeTimeOut = newClip.RelativeTimeIn + newClip.Length;
newClip.AngleIndex = clip.AngleIndex;
newClip.Chapters.Add(clip.TimeIn);
StreamClips.Add(newClip);
if (newClip.AngleIndex > AngleCount)
{
AngleCount = newClip.AngleIndex;
}
if (newClip.AngleIndex == 0)
{
Chapters.Add(newClip.RelativeTimeIn);
}
}
LoadStreamClips();
IsInitialized = true;
}
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());
}
//private BackgroundWorker InitBDROMWorker = null;
public void InitBDROM(string path)
{
System.Console.WriteLine("Please wait while we scan the disc...");
try
{
BDROM = new BDROM(path);
BDROM.StreamClipFileScanError += new BDROM.OnStreamClipFileScanError(BDROM_StreamClipFileScanError);
BDROM.StreamFileScanError += new BDROM.OnStreamFileScanError(BDROM_StreamFileScanError);
BDROM.PlaylistFileScanError += new BDROM.OnPlaylistFileScanError(BDROM_PlaylistFileScanError);
BDROM.Scan();
System.Console.WriteLine(BDROM.DirectoryRoot.FullName);
System.Console.WriteLine(string.Format("Detected BDMV Folder: {0} ({1})", BDROM.DirectoryBDMV.FullName, BDROM.VolumeLabel));
List<string> features = new List<string>();
if (BDROM.Is50Hz)
{
features.Add("50Hz Content");
}
if (BDROM.IsBDPlus)
{
features.Add("BD+ Copy Protection");
}
if (BDROM.IsBDJava)
{
features.Add("BD-Java");
}
if (BDROM.Is3D)
{
features.Add("Blu-ray 3D");
}
if (BDROM.IsDBOX)
{
features.Add("D-BOX Motion Code");
}
if (BDROM.IsPSP)
{
features.Add("PSP Digital Copy");
}
if (features.Count > 0)
{
System.Console.WriteLine("Detected Features: " + string.Join(", ", features.ToArray()));
}
System.Console.WriteLine(string.Format("Disc Size: {0:N0} bytes{1}", BDROM.Size, Environment.NewLine));
}
catch (Exception ex)
{
throw ex;
}
}
public void Generate(
BDROM BDROM,
List <TSPlaylistFile> playlists,
ScanBDROMResult scanResult)
{
Playlists = playlists;
StreamWriter reportFile = null;
if (BDInfoSettings.AutosaveReport)
{
string reportName = string.Format(
"BDINFO.{0}.txt",
BDROM.VolumeLabel);
reportFile = File.CreateText(Path.Combine(Environment.CurrentDirectory, reportName));
}
textBoxReport.Text = "";
string protection = (BDROM.IsBDPlus ? "BD+" : "AACS");
string bdjava = (BDROM.IsBDJava ? "Yes" : "No");
List <string> extraFeatures = new List <string>();
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 += string.Format(
"{0,-16}{1}\r\n", "Extras:", string.Join(", ", extraFeatures.ToArray()));
}
if (scanResult.ScanException != null)
{
report += string.Format(
"WARNING: Report is incomplete because: {0}\r\n",
scanResult.ScanException.Message);
}
if (scanResult.FileExceptions.Count > 0)
{
report += "WARNING: File errors were encountered during scan:\r\n";
foreach (string fileName in scanResult.FileExceptions.Keys)
{
Exception fileException = scanResult.FileExceptions[fileName];
report += string.Format(
"\r\n{0}\t{1}\r\n", fileName, fileException.Message);
report += string.Format(
"{0}\r\n", fileException.StackTrace);
}
}
foreach (TSPlaylistFile playlist in playlists)
{
string summary = "";
comboBoxPlaylist.Items.Add(playlist);
string title = playlist.Name;
string discSize = string.Format(
"{0:N0}", BDROM.Size);
TimeSpan playlistTotalLength =
new TimeSpan((long)(playlist.TotalLength * 10000000));
string totalLength = string.Format(
"{0:D1}:{1:D2}:{2:D2}.{3:D3}",
playlistTotalLength.Hours,
playlistTotalLength.Minutes,
playlistTotalLength.Seconds,
playlistTotalLength.Milliseconds);
string totalLengthShort = string.Format(
"{0:D1}:{1:D2}:{2:D2}",
playlistTotalLength.Hours,
playlistTotalLength.Minutes,
playlistTotalLength.Seconds);
string totalSize = string.Format(
"{0:N0}", playlist.TotalSize);
string totalBitrate = string.Format(
"{0:F2}",
Math.Round((double)playlist.TotalBitRate / 10000) / 100);
TimeSpan playlistAngleLength =
new TimeSpan((long)(playlist.TotalAngleLength * 10000000));
string totalAngleLength = string.Format(
"{0:D1}:{1:D2}:{2:D2}.{3:D3}",
playlistAngleLength.Hours,
playlistAngleLength.Minutes,
playlistAngleLength.Seconds,
playlistAngleLength.Milliseconds);
string totalAngleSize = string.Format(
"{0:N0}", playlist.TotalAngleSize);
string totalAngleBitrate = string.Format(
"{0:F2}",
Math.Round((double)playlist.TotalAngleBitRate / 10000) / 100);
List <string> angleLengths = new List <string>();
List <string> angleSizes = new List <string>();
List <string> angleBitrates = new List <string>();
List <string> angleTotalLengths = new List <string>();
List <string> angleTotalSizes = new List <string>();
List <string> angleTotalBitrates = new List <string>();
if (playlist.AngleCount > 0)
{
for (int 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 (TSStreamClip clip in playlist.AngleClips[angleIndex].Values)
{
angleTotalSize += clip.PacketSize;
if (clip.AngleIndex == angleIndex + 1)
{
angleSize += clip.PacketSize;
angleLength += clip.Length;
}
}
}
angleSizes.Add(string.Format(
"{0:N0}", angleSize));
TimeSpan angleTimeSpan =
new TimeSpan((long)(angleLength * 10000000));
angleLengths.Add(string.Format(
"{0:D1}:{1:D2}:{2:D2}.{3:D3}",
angleTimeSpan.Hours,
angleTimeSpan.Minutes,
angleTimeSpan.Seconds,
angleTimeSpan.Milliseconds));
angleTotalSizes.Add(string.Format(
"{0:N0}", angleTotalSize));
angleTotalLengths.Add(totalLength);
double angleBitrate = 0;
if (angleLength > 0)
{
angleBitrate = Math.Round((double)(angleSize * 8) / angleLength / 10000) / 100;
}
angleBitrates.Add(string.Format("{0:F2}", angleBitrate));
double angleTotalBitrate = 0;
if (playlist.TotalLength > 0)
{
angleTotalBitrate = Math.Round((double)(angleTotalSize * 8) / playlist.TotalLength / 10000) / 100;
}
angleTotalBitrates.Add(string.Format(
"{0:F2}", angleTotalBitrate));
}
}
string videoCodec = "";
string videoBitrate = "";
if (playlist.VideoStreams.Count > 0)
{
TSStream videoStream = playlist.VideoStreams[0];
videoCodec = videoStream.CodecAltName;
videoBitrate = string.Format(
"{0:F2}", Math.Round((double)videoStream.BitRate / 10000) / 100);
}
string audio1 = "";
string languageCode1 = "";
if (playlist.AudioStreams.Count > 0)
{
TSAudioStream audioStream = playlist.AudioStreams[0];
languageCode1 = audioStream.LanguageCode;
audio1 = string.Format(
"{0} {1}",
audioStream.CodecAltName,
audioStream.ChannelDescription);
if (audioStream.BitRate > 0)
{
audio1 += string.Format(
" {0} Kbps",
(int)Math.Round((double)audioStream.BitRate / 1000));
}
if (audioStream.SampleRate > 0 &&
audioStream.BitDepth > 0)
{
audio1 += string.Format(
" ({0} kHz/{1}-bit)",
(int)Math.Round((double)audioStream.SampleRate / 1000),
audioStream.BitDepth);
}
}
string audio2 = "";
if (playlist.AudioStreams.Count > 1)
{
for (int i = 1; i < playlist.AudioStreams.Count; i++)
{
TSAudioStream 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(
"{0} {1}",
audioStream.CodecAltName, audioStream.ChannelDescription);
if (audioStream.BitRate > 0)
{
audio2 += string.Format(
" {0} kbps",
(int)Math.Round((double)audioStream.BitRate / 1000));
}
if (audioStream.SampleRate > 0 &&
audioStream.BitDepth > 0)
{
audio2 += string.Format(
" ({0} kHz/{1}-bit)",
(int)Math.Round((double)audioStream.SampleRate / 1000),
audioStream.BitDepth);
}
break;
}
}
}
report += "DISC INFO:\r\n";
report += "\r\n";
report += string.Format(
"{0,-16}{1}\r\n", "Disc Title:", BDROM.VolumeLabel);
report += string.Format(
"{0,-16}{1:N0} bytes\r\n", "Disc Size:", BDROM.Size);
report += string.Format(
"{0,-16}{1}\r\n", "Protection:", protection);
report += string.Format(
"{0,-16}{1}\r\n", "BD-Java:", bdjava);
if (extraFeatures.Count > 0)
{
report += string.Format(
"{0,-16}{1}\r\n", "Extras:", string.Join(", ", extraFeatures.ToArray()));
}
report += string.Format(
"{0,-16}{1}\r\n", "TDMaker:", Application.ProductVersion + " (BDInfo 0.5.8)");
report += "\r\n";
report += "PLAYLIST REPORT:\r\n";
report += "\r\n";
report += string.Format(
"{0,-24}{1}\r\n", "Name:", title);
report += string.Format(
"{0,-24}{1} (h:m:s.ms)\r\n", "Length:", totalLength);
report += string.Format(
"{0,-24}{1:N0} bytes\r\n", "Size:", totalSize);
report += string.Format(
"{0,-24}{1} Mbps\r\n", "Total Bitrate:", totalBitrate);
if (playlist.AngleCount > 0)
{
for (int angleIndex = 0; angleIndex < playlist.AngleCount; angleIndex++)
{
report += "\r\n";
report += string.Format(
"{0,-24}{1} (h:m:s.ms) / {2} (h:m:s.ms)\r\n", string.Format("Angle {0} Length:", angleIndex + 1),
angleLengths[angleIndex], angleTotalLengths[angleIndex]);
report += string.Format(
"{0,-24}{1:N0} bytes / {2:N0} bytes\r\n", string.Format("Angle {0} Size:", angleIndex + 1),
angleSizes[angleIndex], angleTotalSizes[angleIndex]);
report += string.Format(
"{0,-24}{1} Mbps / {2} Mbps\r\n", string.Format("Angle {0} Total Bitrate:", angleIndex + 1),
angleBitrates[angleIndex], angleTotalBitrates[angleIndex], angleIndex);
}
report += "\r\n";
report += string.Format(
"{0,-24}{1} (h:m:s.ms)\r\n", "All Angles Length:", totalAngleLength);
report += string.Format(
"{0,-24}{1} bytes\r\n", "All Angles Size:", totalAngleSize);
report += string.Format(
"{0,-24}{1} Mbps\r\n", "All Angles Bitrate:", totalAngleBitrate);
}
/*
* report += string.Format(
* "{0,-24}{1}\r\n", "Description:", "");
*/
summary += string.Format(
"Disc Title: {0}\r\n", BDROM.VolumeLabel);
summary += string.Format(
"Disc Size: {0:N0} bytes\r\n", BDROM.Size);
summary += string.Format(
"Protection: {0}\r\n", protection);
summary += string.Format(
"BD-Java: {0}\r\n", bdjava);
summary += string.Format(
"Playlist: {0}\r\n", title);
summary += string.Format(
"Size: {0:N0} bytes\r\n", totalSize);
summary += string.Format(
"Length: {0}\r\n", totalLength);
summary += string.Format(
"Total Bitrate: {0} Mbps\r\n", totalBitrate);
if (playlist.HasHiddenTracks)
{
report += "\r\n(*) Indicates included stream hidden by this playlist.\r\n";
}
if (playlist.VideoStreams.Count > 0)
{
report += "\r\n";
report += "VIDEO:\r\n";
report += "\r\n";
report += string.Format(
"{0,-24}{1,-20}{2,-16}\r\n",
"Codec",
"Bitrate",
"Description");
report += string.Format(
"{0,-24}{1,-20}{2,-16}\r\n",
"-----",
"-------",
"-----------");
foreach (TSStream stream in playlist.SortedStreams)
{
if (!stream.IsVideoStream)
{
continue;
}
string streamName = stream.CodecName;
if (stream.AngleIndex > 0)
{
streamName += string.Format(
" ({0})", stream.AngleIndex);
}
string streamBitrate = string.Format(
"{0:D}",
(int)Math.Round((double)stream.BitRate / 1000));
if (stream.AngleIndex > 0)
{
streamBitrate += string.Format(
" ({0:D})",
(int)Math.Round((double)stream.ActiveBitRate / 1000));
}
streamBitrate += " kbps";
report += string.Format(
"{0,-24}{1,-20}{2,-16}\r\n",
(stream.IsHidden ? "* " : "") + streamName,
streamBitrate,
stream.Description);
summary += string.Format(
(stream.IsHidden ? "* " : "") + "Video: {0} / {1} / {2}\r\n",
streamName,
streamBitrate,
stream.Description);
}
}
if (playlist.AudioStreams.Count > 0)
{
report += "\r\n";
report += "AUDIO:\r\n";
report += "\r\n";
report += string.Format(
"{0,-32}{1,-16}{2,-16}{3,-16}\r\n",
"Codec",
"Language",
"Bitrate",
"Description");
report += string.Format(
"{0,-32}{1,-16}{2,-16}{3,-16}\r\n",
"-----",
"--------",
"-------",
"-----------");
foreach (TSStream stream in playlist.SortedStreams)
{
if (!stream.IsAudioStream)
{
continue;
}
string streamBitrate = string.Format(
"{0:D} kbps",
(int)Math.Round((double)stream.BitRate / 1000));
report += string.Format(
"{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 += "\r\n";
report += "SUBTITLES:\r\n";
report += "\r\n";
report += string.Format(
"{0,-32}{1,-16}{2,-16}{3,-16}\r\n",
"Codec",
"Language",
"Bitrate",
"Description");
report += string.Format(
"{0,-32}{1,-16}{2,-16}{3,-16}\r\n",
"-----",
"--------",
"-------",
"-----------");
foreach (TSStream stream in playlist.SortedStreams)
{
if (!stream.IsGraphicsStream)
{
continue;
}
string streamBitrate = string.Format(
"{0:F3} kbps",
(double)stream.BitRate / 1000);
report += string.Format(
"{0,-32}{1,-16}{2,-16}{3,-16}\r\n",
(stream.IsHidden ? "* " : "") + stream.CodecName,
stream.LanguageName,
streamBitrate,
stream.Description);
summary += string.Format(
(stream.IsHidden ? "* " : "") + "Subtitle: {0} / {1}\r\n",
stream.LanguageName,
streamBitrate,
stream.Description);
}
}
if (playlist.TextStreams.Count > 0)
{
report += "\r\n";
report += "TEXT:\r\n";
report += "\r\n";
report += string.Format(
"{0,-32}{1,-16}{2,-16}{3,-16}\r\n",
"Codec",
"Language",
"Bitrate",
"Description");
report += string.Format(
"{0,-32}{1,-16}{2,-16}{3,-16}\r\n",
"-----",
"--------",
"-------",
"-----------");
foreach (TSStream stream in playlist.SortedStreams)
{
if (!stream.IsTextStream)
{
continue;
}
string streamBitrate = string.Format(
"{0:F3} kbps",
(double)stream.BitRate / 1000);
report += string.Format(
"{0,-32}{1,-16}{2,-16}{3,-16}\r\n",
(stream.IsHidden ? "* " : "") + stream.CodecName,
stream.LanguageName,
streamBitrate,
stream.Description);
}
}
report += "\r\n";
if (BDInfoSettings.AutosaveReport && reportFile != null)
{
try { reportFile.Write(report); }
catch { }
}
textBoxReport.Text += report;
GC.Collect();
}
if (BDInfoSettings.AutosaveReport && reportFile != null)
{
try { reportFile.Write(report); }
catch { }
}
textBoxReport.Text += report;
if (reportFile != null)
{
reportFile.Close();
}
textBoxReport.Select(0, 0);
comboBoxPlaylist.SelectedIndex = 0;
comboBoxChartType.SelectedIndex = 0;
}
public TSPlaylistFile(
BDROM bdrom,
string name,
IEnumerable<TSStreamClip> clips)
{
BDROM = bdrom;
Name = name;
FullName = Path.Combine(bdrom.DirectoryPLAYLIST.FullName, Name).ToUpper();
IsCustom = true;
foreach (var clip in clips)
{
var newClip = new TSStreamClip(clip.StreamFile, clip.StreamClipFile)
{
Name = clip.Name,
TimeIn = clip.TimeIn,
TimeOut = clip.TimeOut,
RelativeTimeIn = TotalLength,
AngleIndex = clip.AngleIndex
};
newClip.Length = newClip.TimeOut - newClip.TimeIn;
newClip.RelativeTimeOut = newClip.RelativeTimeIn + newClip.Length;
newClip.Chapters.Add(clip.TimeIn);
StreamClips.Add(newClip);
if (newClip.AngleIndex > AngleCount)
{
AngleCount = newClip.AngleIndex;
}
if (newClip.AngleIndex == 0)
{
Chapters.Add(newClip.RelativeTimeIn);
}
}
LoadStreamClips();
_isInitialized = true;
}
private void GetBDInfo()
{
string strChapters = Processing.GetResourceString("streamselect_chapters");
string strVideo = Processing.GetResourceString("streamselect_video");
string strAudio = Processing.GetResourceString("streamselect_audio");
string strSubtitles = Processing.GetResourceString("streamselect_subtitles");
string bdTitleFormat = Processing.GetResourceString("streamselect_bd_general");
const string bdAudioFormat = "{5:g}: {0} ({1}) / {2} ({3}) / {4}";
const string bdSubFormat = "{3:g}: {0} / {1} ({2}); {4}";
_bdInfo = new BDROM(JobInfo.InputFile);
_bdInfo.Scan();
int longestClip = GetLongestBDPlaylist();
int playlistIndex = 1;
foreach (TSPlaylistFile item in _bdInfo.PlaylistFiles.Values)
{
if (!item.IsValid)
{
playlistIndex++;
continue;
}
int streamIndex = 0;
DateTime duration = new DateTime();
duration = duration.AddSeconds(item.TotalLength);
string treeRoot = string.Format(bdTitleFormat, playlistIndex, item.Name,
duration.ToString("H:mm:ss.fff"));
Dictionary<string, object> treeData = new Dictionary<string, object>
{
{
"Name",
Path.Combine(_bdInfo.DirectoryPLAYLIST.FullName,
item.Name)
},
{"PlaylistIndex", playlistIndex}
};
TreeNode root = new TreeNode
{
ID = _treeNodeID++,
Name = treeRoot,
Data = treeData,
Children = new List<TreeNode>(),
IsChecked = true,
};
root.IsExpanded = root.IsChecked;
_tree.Add(root);
TreeNode chaptersTree = CreateNode(root, strChapters, null);
TreeNode videoTree = CreateNode(root, strVideo, null);
TreeNode audioTree = CreateNode(root, strAudio, null);
TreeNode subTree = CreateNode(root, strSubtitles, null);
List<TimeSpan> streamChapters = new List<TimeSpan>();
if (item.Chapters.Count > 1)
{
streamIndex++;
streamChapters.AddRange(item.Chapters.Select(TimeSpan.FromSeconds));
string chaptersFormat = string.Format("{0:0} {1}", streamChapters.Count, strChapters);
CreateNode(chaptersTree, chaptersFormat, streamChapters);
}
string videoDescStereo = string.Empty;
int leftVideoStreamID = -1;
foreach (TSVideoStream clip in item.VideoStreams)
{
streamIndex++;
string videoCodec = clip.CodecName;
string videoCodecShort = clip.CodecShortName;
string videoDesc = clip.Description;
if ((clip.StreamType == TSStreamType.AVC_VIDEO) && (item.VideoStreams.Count > 1)
&& (item.VideoStreams[0].PID == clip.PID)
&& (item.VideoStreams[item.VideoStreams.Count - 1].StreamType == TSStreamType.MVC_VIDEO))
{
videoDescStereo = videoDesc;
videoCodec += " (left eye)";
leftVideoStreamID = streamIndex;
}
if ((clip.StreamType == TSStreamType.MVC_VIDEO) && (item.VideoStreams.Count > 1)
&& (item.VideoStreams[item.VideoStreams.Count - 1].PID == clip.PID)
&& (item.VideoStreams[0].StreamType == TSStreamType.AVC_VIDEO))
{
videoDesc = videoDescStereo;
videoCodec = "MPEG-4 MVC Video (right eye)";
}
/* */
string videoStreamFormat = string.Format("{3:g}: {0} ({1}), {2}", videoCodec, videoCodecShort,
videoDesc, streamIndex);
switch (clip.StreamType)
{
case TSStreamType.AVC_VIDEO:
case TSStreamType.MPEG2_VIDEO:
case TSStreamType.MPEG1_VIDEO:
case TSStreamType.VC1_VIDEO:
{
VideoInfo vid = new VideoInfo
{
StreamId = streamIndex,
TrackId = playlistIndex,
FPS = (float) clip.FrameRateEnumerator/clip.FrameRateDenominator,
PicSize = (VideoFormat) clip.VideoFormat,
Interlaced = clip.IsInterlaced,
Format = clip.CodecShortName,
DemuxStreamId = clip.PID,
FrameCount = 0,
Encoded = false,
IsRawStream = false,
StreamSize = 0,
Length = item.TotalLength,
FrameRateEnumerator = clip.FrameRateEnumerator,
FrameRateDenominator = clip.FrameRateDenominator,
Height = clip.Height
};
Int32.TryParse(item.Name.Substring(0, item.Name.LastIndexOf('.')), NumberStyles.Number,
AppSettings.CInfo, out vid.DemuxPlayList);
foreach (TSStreamClip streamClip in item.StreamClips)
vid.DemuxStreamNames.Add(streamClip.StreamFile.FileInfo.FullName);
float mod;
switch (clip.AspectRatio)
{
case TSAspectRatio.ASPECT_16_9:
mod = (float) 1.777778;
break;
default:
mod = (float) 1.333333;
break;
}
vid.Width = (int) (vid.Height*mod);
vid.AspectRatio = mod;
CreateNode(videoTree, videoStreamFormat, vid);
}
break;
case TSStreamType.MVC_VIDEO:
{
StereoVideoInfo vid = new StereoVideoInfo
{
RightStreamId = streamIndex,
LeftStreamId = leftVideoStreamID
};
CreateNode(videoTree, videoStreamFormat, vid);
}
break;
}
}
foreach (TSAudioStream audio in item.AudioStreams)
{
streamIndex++;
string audioCodec = audio.CodecName;
string audioCodecShort = audio.CodecShortName;
string audioDesc = audio.Description;
string audioLangCode = audio.LanguageCode;
string audioLanguage = audio.LanguageName;
string audioStreamFormat = string.Format(bdAudioFormat, audioCodec, audioCodecShort, audioLangCode,
audioLanguage, audioDesc, streamIndex);
AudioInfo aud = new AudioInfo
{
Format = audioCodecShort,
FormatProfile = string.Empty,
Id = streamIndex,
StreamId = streamIndex,
LangCode = audioLangCode,
TempFile = string.Empty,
OriginalId = streamIndex,
Delay = 0,
Bitrate = audio.BitRate,
DemuxStreamId = audio.PID,
SampleRate = audio.SampleRate,
ChannelCount = audio.ChannelCount + audio.LFE,
BitDepth = audio.BitDepth,
ShortLang = audio.LanguageCode,
StreamSize = 0,
Length = item.TotalLength,
IsHdStream = audio.CoreStream != null
};
CreateNode(audioTree, audioStreamFormat, aud);
}
foreach (TSTextStream sub in item.TextStreams)
{
streamIndex++;
string subCodecShort = sub.CodecShortName;
string subDesc = sub.Description;
string subLangCode = sub.LanguageCode;
string subLanguage = sub.LanguageName;
string subStreamFormat = string.Format(bdSubFormat, subCodecShort, subLangCode, subLanguage,
streamIndex, subDesc);
SubtitleInfo subInfo = new SubtitleInfo
{
Id = streamIndex,
StreamId = streamIndex,
TempFile = string.Empty,
LangCode = subLangCode,
Format = subCodecShort,
Delay = 0,
DemuxStreamId = sub.PID,
StreamSize = 0
};
CreateNode(subTree, subStreamFormat, subInfo);
}
foreach (TSGraphicsStream sub in item.GraphicsStreams)
{
streamIndex++;
string subCodecShort = sub.CodecShortName;
string subDesc = sub.Description;
string subLangCode = sub.LanguageCode;
string subLanguage = sub.LanguageName;
string subStreamFormat = string.Format(bdSubFormat, subCodecShort, subLangCode, subLanguage,
streamIndex, subDesc);
SubtitleInfo subInfo = new SubtitleInfo
{
Id = streamIndex,
StreamId = streamIndex,
TempFile = string.Empty,
LangCode = subLangCode,
Format = subCodecShort,
DemuxStreamId = sub.PID,
StreamSize = 0
};
CreateNode(subTree, subStreamFormat, subInfo);
}
playlistIndex++;
}
_defaultSelection = longestClip - 1;
}
/// <summary>
/// Gets the disc info.
/// </summary>
/// <param name="path">The path.</param>
/// <returns>BlurayDiscInfo.</returns>
public BlurayDiscInfo GetDiscInfo(string path)
{
var bdrom = new BDROM(path);
bdrom.Scan();
// Get the longest playlist
var playlist = bdrom.PlaylistFiles.Values.OrderByDescending(p => p.TotalLength).FirstOrDefault(p => p.IsValid);
var outputStream = new BlurayDiscInfo
{
MediaStreams = new List<MediaStream>()
};
if (playlist == null)
{
return outputStream;
}
outputStream.Chapters = playlist.Chapters;
outputStream.RunTimeTicks = TimeSpan.FromSeconds(playlist.TotalLength).Ticks;
var mediaStreams = new List<MediaStream> { };
foreach (var stream in playlist.SortedStreams)
{
var videoStream = stream as TSVideoStream;
if (videoStream != null)
{
AddVideoStream(mediaStreams, videoStream);
continue;
}
var audioStream = stream as TSAudioStream;
if (audioStream != null)
{
AddAudioStream(mediaStreams, audioStream);
continue;
}
var textStream = stream as TSTextStream;
if (textStream != null)
{
AddSubtitleStream(mediaStreams, textStream);
continue;
}
var graphicsStream = stream as TSGraphicsStream;
if (graphicsStream != null)
{
AddSubtitleStream(mediaStreams, graphicsStream);
}
}
outputStream.MediaStreams = mediaStreams;
outputStream.PlaylistName = playlist.Name;
if (playlist.StreamClips != null && playlist.StreamClips.Any())
{
// Get the files in the playlist
outputStream.Files = playlist.StreamClips.Select(i => i.StreamFile.Name).ToList();
}
return outputStream;
}
public void Generate(
BDROM BDROM,
List<TSPlaylistFile> playlists,
ScanBDROMResult scanResult)
{
Playlists = playlists;
StreamWriter reportFile = null;
if (BDInfoSettings.AutosaveReport)
{
string reportName = string.Format(
"BDINFO.{0}.txt",
BDROM.VolumeLabel);
reportFile = File.CreateText(Path.Combine(Environment.CurrentDirectory, reportName));
}
textBoxReport.Text = "";
string protection = (BDROM.IsBDPlus ? "BD+" : "AACS");
string bdjava = (BDROM.IsBDJava ? "Yes" : "No");
report += string.Format(
"{0,-16}{1}\r\n", "Disc Title:", BDROM.VolumeLabel);
report += string.Format(
"{0,-16}{1:N0} bytes\r\n", "Disc Size:", BDROM.Size);
report += string.Format(
"{0,-16}{1}\r\n", "Protection:", protection);
report += string.Format(
"{0,-16}{1}\r\n", "BD-Java:", bdjava);
List<string> extraFeatures = new List<string>();
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 += string.Format(
"{0,-16}{1}\r\n", "Extras:", string.Join(", ", extraFeatures.ToArray()));
}
report += string.Format(
"{0,-16}{1}\r\n", "BDInfo:", Application.ProductVersion);
report += "\r\n";
report += string.Format(
"{0,-16}{1}\r\n", "Notes:", "");
report += "\r\n";
report += "BDINFO HOME:\r\n";
report += " Cinema Squid\r\n";
report += " http://www.cinemasquid.com/blu-ray/tools/bdinfo\r\n";
report += "\r\n";
report += "INCLUDES FORUMS REPORT FOR:\r\n";
report += " AVS Forum Blu-ray Audio and Video Specifications Thread\r\n";
report += " http://www.avsforum.com/avs-vb/showthread.php?t=1155731\r\n";
report += "\r\n";
if (scanResult.ScanException != null)
{
report += string.Format(
"WARNING: Report is incomplete because: {0}\r\n",
scanResult.ScanException.Message);
}
if (scanResult.FileExceptions.Count > 0)
{
report += "WARNING: File errors were encountered during scan:\r\n";
foreach (string fileName in scanResult.FileExceptions.Keys)
{
Exception fileException = scanResult.FileExceptions[fileName];
report += string.Format(
"\r\n{0}\t{1}\r\n", fileName, fileException.Message);
report += string.Format(
"{0}\r\n", fileException.StackTrace);
}
}
foreach (TSPlaylistFile playlist in playlists)
{
string summary = "";
comboBoxPlaylist.Items.Add(playlist);
string title = playlist.Name;
string discSize = string.Format(
"{0:N0}", BDROM.Size);
TimeSpan playlistTotalLength =
new TimeSpan((long)(playlist.TotalLength * 10000000));
string totalLength = string.Format(
"{0:D1}:{1:D2}:{2:D2}.{3:D3}",
playlistTotalLength.Hours,
playlistTotalLength.Minutes,
playlistTotalLength.Seconds,
playlistTotalLength.Milliseconds);
string totalLengthShort = string.Format(
"{0:D1}:{1:D2}:{2:D2}",
playlistTotalLength.Hours,
playlistTotalLength.Minutes,
playlistTotalLength.Seconds);
string totalSize = string.Format(
"{0:N0}", playlist.TotalSize);
string totalBitrate = string.Format(
"{0:F2}",
Math.Round((double)playlist.TotalBitRate / 10000) / 100);
TimeSpan playlistAngleLength =
new TimeSpan((long)(playlist.TotalAngleLength * 10000000));
string totalAngleLength = string.Format(
"{0:D1}:{1:D2}:{2:D2}.{3:D3}",
playlistAngleLength.Hours,
playlistAngleLength.Minutes,
playlistAngleLength.Seconds,
playlistAngleLength.Milliseconds);
string totalAngleSize = string.Format(
"{0:N0}", playlist.TotalAngleSize);
string totalAngleBitrate = string.Format(
"{0:F2}",
Math.Round((double)playlist.TotalAngleBitRate / 10000) / 100);
List<string> angleLengths = new List<string>();
List<string> angleSizes = new List<string>();
List<string> angleBitrates = new List<string>();
List<string> angleTotalLengths = new List<string>();
List<string> angleTotalSizes = new List<string>();
List<string> angleTotalBitrates = new List<string>();
if (playlist.AngleCount > 0)
{
for (int 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 (TSStreamClip clip in playlist.AngleClips[angleIndex].Values)
{
angleTotalSize += clip.PacketSize;
if (clip.AngleIndex == angleIndex + 1)
{
angleSize += clip.PacketSize;
angleLength += clip.Length;
}
}
}
angleSizes.Add(string.Format(
"{0:N0}", angleSize));
TimeSpan angleTimeSpan =
new TimeSpan((long)(angleLength * 10000000));
angleLengths.Add(string.Format(
"{0:D1}:{1:D2}:{2:D2}.{3:D3}",
angleTimeSpan.Hours,
angleTimeSpan.Minutes,
angleTimeSpan.Seconds,
angleTimeSpan.Milliseconds));
angleTotalSizes.Add(string.Format(
"{0:N0}", angleTotalSize));
angleTotalLengths.Add(totalLength);
double angleBitrate = 0;
if (angleLength > 0)
{
angleBitrate = Math.Round((double)(angleSize * 8) / angleLength / 10000) / 100;
}
angleBitrates.Add(string.Format("{0:F2}", angleBitrate));
double angleTotalBitrate = 0;
if (playlist.TotalLength > 0)
{
angleTotalBitrate = Math.Round((double)(angleTotalSize * 8) / playlist.TotalLength / 10000) / 100;
}
angleTotalBitrates.Add(string.Format(
"{0:F2}", angleTotalBitrate));
}
}
string videoCodec = "";
string videoBitrate = "";
if (playlist.VideoStreams.Count > 0)
{
TSStream videoStream = playlist.VideoStreams[0];
videoCodec = videoStream.CodecAltName;
videoBitrate = string.Format(
"{0:F2}", Math.Round((double)videoStream.BitRate / 10000) / 100);
}
string audio1 = "";
string languageCode1 = "";
if (playlist.AudioStreams.Count > 0)
{
TSAudioStream audioStream = playlist.AudioStreams[0];
languageCode1 = audioStream.LanguageCode;
audio1 = string.Format(
"{0} {1}",
audioStream.CodecAltName,
audioStream.ChannelDescription);
if (audioStream.BitRate > 0)
{
audio1 += string.Format(
" {0}Kbps",
(int)Math.Round((double)audioStream.BitRate / 1000));
}
if (audioStream.SampleRate > 0 &&
audioStream.BitDepth > 0)
{
audio1 += string.Format(
" ({0}kHz/{1}-bit)",
(int)Math.Round((double)audioStream.SampleRate / 1000),
audioStream.BitDepth);
}
}
string audio2 = "";
if (playlist.AudioStreams.Count > 1)
{
for (int i = 1; i < playlist.AudioStreams.Count; i++)
{
TSAudioStream 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(
"{0} {1}",
audioStream.CodecAltName, audioStream.ChannelDescription);
if (audioStream.BitRate > 0)
{
audio2 += string.Format(
" {0}Kbps",
(int)Math.Round((double)audioStream.BitRate / 1000));
}
if (audioStream.SampleRate > 0 &&
audioStream.BitDepth > 0)
{
audio2 += string.Format(
" ({0}kHz/{1}-bit)",
(int)Math.Round((double)audioStream.SampleRate / 1000),
audioStream.BitDepth);
}
break;
}
}
}
report += "\r\n";
report += "********************\r\n";
report += "PLAYLIST: " + playlist.Name + "\r\n";
report += "********************\r\n";
report += "\r\n";
report += "<--- BEGIN FORUMS PASTE --->\r\n";
report += "[code]\r\n";
report += string.Format(
"{0,-64}{1,-8}{2,-8}{3,-16}{4,-16}{5,-8}{6,-8}{7,-42}{8}\r\n",
"",
"",
"",
"",
"",
"Total",
"Video",
"",
"");
report += string.Format(
"{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 += string.Format(
"{0,-64}{1,-8}{2,-8}{3,-16}{4,-16}{5,-8}{6,-8}{7,-42}{8}\r\n",
"-----",
"------",
"-------",
"--------------",
"--------------",
"-------",
"-------",
"------------------",
"---------------------");
report += string.Format(
"{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 += "[/code]\r\n";
report += "\r\n";
report += "[code]\r\n";
report += "\r\n";
report += "DISC INFO:\r\n";
report += "\r\n";
report += string.Format(
"{0,-16}{1}\r\n", "Disc Title:", BDROM.VolumeLabel);
report += string.Format(
"{0,-16}{1:N0} bytes\r\n", "Disc Size:", BDROM.Size);
report += string.Format(
"{0,-16}{1}\r\n", "Protection:", protection);
report += string.Format(
"{0,-16}{1}\r\n", "BD-Java:", bdjava);
if (extraFeatures.Count > 0)
{
report += string.Format(
"{0,-16}{1}\r\n", "Extras:", string.Join(", ", extraFeatures.ToArray()));
}
report += string.Format(
"{0,-16}{1}\r\n", "BDInfo:", Application.ProductVersion);
report += "\r\n";
report += "PLAYLIST REPORT:\r\n";
report += "\r\n";
report += string.Format(
"{0,-24}{1}\r\n", "Name:", title);
report += string.Format(
"{0,-24}{1} (h:m:s.ms)\r\n", "Length:", totalLength);
report += string.Format(
"{0,-24}{1:N0} bytes\r\n", "Size:", totalSize);
report += string.Format(
"{0,-24}{1} Mbps\r\n", "Total Bitrate:", totalBitrate);
if (playlist.AngleCount > 0)
{
for (int angleIndex = 0; angleIndex < playlist.AngleCount; angleIndex++)
{
report += "\r\n";
report += string.Format(
"{0,-24}{1} (h:m:s.ms) / {2} (h:m:s.ms)\r\n", string.Format("Angle {0} Length:", angleIndex + 1),
angleLengths[angleIndex], angleTotalLengths[angleIndex]);
report += string.Format(
"{0,-24}{1:N0} bytes / {2:N0} bytes\r\n", string.Format("Angle {0} Size:", angleIndex + 1),
angleSizes[angleIndex], angleTotalSizes[angleIndex]);
report += string.Format(
"{0,-24}{1} Mbps / {2} Mbps\r\n", string.Format("Angle {0} Total Bitrate:", angleIndex + 1),
angleBitrates[angleIndex], angleTotalBitrates[angleIndex], angleIndex);
}
report += "\r\n";
report += string.Format(
"{0,-24}{1} (h:m:s.ms)\r\n", "All Angles Length:", totalAngleLength);
report += string.Format(
"{0,-24}{1} bytes\r\n", "All Angles Size:", totalAngleSize);
report += string.Format(
"{0,-24}{1} Mbps\r\n", "All Angles Bitrate:", totalAngleBitrate);
}
/*
report += string.Format(
"{0,-24}{1}\r\n", "Description:", "");
*/
summary += string.Format(
"Disc Title: {0}\r\n", BDROM.VolumeLabel);
summary += string.Format(
"Disc Size: {0:N0} bytes\r\n", BDROM.Size);
summary += string.Format(
"Protection: {0}\r\n", protection);
summary += string.Format(
"BD-Java: {0}\r\n", bdjava);
summary += string.Format(
"Playlist: {0}\r\n", title);
summary += string.Format(
"Size: {0:N0} bytes\r\n", totalSize);
summary += string.Format(
"Length: {0}\r\n", totalLength);
summary += string.Format(
"Total Bitrate: {0} Mbps\r\n", totalBitrate);
if (playlist.HasHiddenTracks)
{
report += "\r\n(*) Indicates included stream hidden by this playlist.\r\n";
}
if (playlist.VideoStreams.Count > 0)
{
report += "\r\n";
report += "VIDEO:\r\n";
report += "\r\n";
report += string.Format(
"{0,-24}{1,-20}{2,-16}\r\n",
"Codec",
"Bitrate",
"Description");
report += string.Format(
"{0,-24}{1,-20}{2,-16}\r\n",
"-----",
"-------",
"-----------");
foreach (TSStream stream in playlist.SortedStreams)
{
if (!stream.IsVideoStream) continue;
string streamName = stream.CodecName;
if (stream.AngleIndex > 0)
{
streamName += string.Format(
" ({0})", stream.AngleIndex);
}
string streamBitrate = string.Format(
"{0:D}",
(int)Math.Round((double)stream.BitRate / 1000));
if (stream.AngleIndex > 0)
{
streamBitrate += string.Format(
" ({0:D})",
(int)Math.Round((double)stream.ActiveBitRate / 1000));
}
streamBitrate += " kbps";
report += string.Format(
"{0,-24}{1,-20}{2,-16}\r\n",
(stream.IsHidden ? "* " : "") + streamName,
streamBitrate,
stream.Description);
summary += string.Format(
(stream.IsHidden ? "* " : "") + "Video: {0} / {1} / {2}\r\n",
streamName,
streamBitrate,
stream.Description);
}
}
if (playlist.AudioStreams.Count > 0)
{
report += "\r\n";
report += "AUDIO:\r\n";
report += "\r\n";
report += string.Format(
"{0,-32}{1,-16}{2,-16}{3,-16}\r\n",
"Codec",
"Language",
"Bitrate",
"Description");
report += string.Format(
"{0,-32}{1,-16}{2,-16}{3,-16}\r\n",
"-----",
"--------",
"-------",
"-----------");
foreach (TSStream stream in playlist.SortedStreams)
{
if (!stream.IsAudioStream) continue;
string streamBitrate = string.Format(
"{0:D} kbps",
(int)Math.Round((double)stream.BitRate / 1000));
report += string.Format(
"{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 += "\r\n";
report += "SUBTITLES:\r\n";
report += "\r\n";
report += string.Format(
"{0,-32}{1,-16}{2,-16}{3,-16}\r\n",
"Codec",
"Language",
"Bitrate",
"Description");
report += string.Format(
"{0,-32}{1,-16}{2,-16}{3,-16}\r\n",
"-----",
"--------",
"-------",
"-----------");
foreach (TSStream stream in playlist.SortedStreams)
{
if (!stream.IsGraphicsStream) continue;
string streamBitrate = string.Format(
"{0:F3} kbps",
(double)stream.BitRate / 1000);
report += string.Format(
"{0,-32}{1,-16}{2,-16}{3,-16}\r\n",
(stream.IsHidden ? "* " : "") + stream.CodecName,
stream.LanguageName,
streamBitrate,
stream.Description);
summary += string.Format(
(stream.IsHidden ? "* " : "") + "Subtitle: {0} / {1}\r\n",
stream.LanguageName,
streamBitrate,
stream.Description);
}
}
if (playlist.TextStreams.Count > 0)
{
report += "\r\n";
report += "TEXT:\r\n";
report += "\r\n";
report += string.Format(
"{0,-32}{1,-16}{2,-16}{3,-16}\r\n",
"Codec",
"Language",
"Bitrate",
"Description");
report += string.Format(
"{0,-32}{1,-16}{2,-16}{3,-16}\r\n",
"-----",
"--------",
"-------",
"-----------");
foreach (TSStream stream in playlist.SortedStreams)
{
if (!stream.IsTextStream) continue;
string streamBitrate = string.Format(
"{0:F3} kbps",
(double)stream.BitRate / 1000);
report += string.Format(
"{0,-32}{1,-16}{2,-16}{3,-16}\r\n",
(stream.IsHidden ? "* " : "") + stream.CodecName,
stream.LanguageName,
streamBitrate,
stream.Description);
}
}
report += "\r\n";
report += "FILES:\r\n";
report += "\r\n";
report += string.Format(
"{0,-16}{1,-16}{2,-16}{3,-16}{4,-16}\r\n",
"Name",
"Time In",
"Length",
"Size",
"Total Bitrate");
report += string.Format(
"{0,-16}{1,-16}{2,-16}{3,-16}{4,-16}\r\n",
"----",
"-------",
"------",
"----",
"-------------");
foreach (TSStreamClip clip in playlist.StreamClips)
{
string clipName = clip.DisplayName;
if (clip.AngleIndex > 0)
{
clipName += string.Format(
" ({0})", clip.AngleIndex);
}
string clipSize = string.Format(
"{0:N0}", clip.PacketSize);
TimeSpan clipInSpan =
new TimeSpan((long)(clip.RelativeTimeIn * 10000000));
TimeSpan clipOutSpan =
new TimeSpan((long)(clip.RelativeTimeOut * 10000000));
TimeSpan clipLengthSpan =
new TimeSpan((long)(clip.Length * 10000000));
string clipTimeIn = string.Format(
"{0:D1}:{1:D2}:{2:D2}.{3:D3}",
clipInSpan.Hours,
clipInSpan.Minutes,
clipInSpan.Seconds,
clipInSpan.Milliseconds);
string clipLength = string.Format(
"{0:D1}:{1:D2}:{2:D2}.{3:D3}",
clipLengthSpan.Hours,
clipLengthSpan.Minutes,
clipLengthSpan.Seconds,
clipLengthSpan.Milliseconds);
string clipBitrate = Math.Round(
(double)clip.PacketBitRate / 1000).ToString("N0");
report += string.Format(
"{0,-16}{1,-16}{2,-16}{3,-16}{4,-16}\r\n",
clipName,
clipTimeIn,
clipLength,
clipSize,
clipBitrate);
}
report += "\r\n";
report += "CHAPTERS:\r\n";
report += "\r\n";
report += string.Format(
"{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 += string.Format(
"{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",
"------",
"-------",
"------",
"--------------",
"--------------",
"--------------",
"--------------",
"--------------",
"--------------",
"--------------",
"--------------",
"--------------",
"--------------");
Queue<double> window1Bits = new Queue<double>();
Queue<double> window1Seconds = new Queue<double>();
double window1BitsSum = 0;
double window1SecondsSum = 0;
double window1PeakBitrate = 0;
double window1PeakLocation = 0;
Queue<double> window5Bits = new Queue<double>();
Queue<double> window5Seconds = new Queue<double>();
double window5BitsSum = 0;
double window5SecondsSum = 0;
double window5PeakBitrate = 0;
double window5PeakLocation = 0;
Queue<double> window10Bits = new Queue<double>();
Queue<double> 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;
ushort diagPID = playlist.VideoStreams[0].PID;
int chapterIndex = 0;
int clipIndex = 0;
int 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;
}
double chapterStart = playlist.Chapters[chapterIndex];
double chapterEnd;
if (chapterIndex < playlist.Chapters.Count - 1)
{
chapterEnd = playlist.Chapters[chapterIndex + 1];
}
else
{
chapterEnd = playlist.TotalLength;
}
double 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)
{
TSStreamDiagnostics diag = diagList[diagIndex++];
if (diag.Marker < clip.TimeIn) continue;
chapterPosition =
diag.Marker -
clip.TimeIn +
clip.RelativeTimeIn;
double seconds = diag.Interval;
double 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)
{
double bitrate = window1BitsSum / window1SecondsSum;
if (bitrate > window1PeakBitrate &&
chapterPosition - window1SecondsSum > 0)
{
window1PeakBitrate = bitrate;
window1PeakLocation = chapterPosition - window1SecondsSum;
}
window1BitsSum -= window1Bits.Dequeue();
window1SecondsSum -= window1Seconds.Dequeue();
}
if (window5SecondsSum > 5.0)
{
double 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)
{
double 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;
TimeSpan window1PeakSpan = new TimeSpan((long)(window1PeakLocation * 10000000));
TimeSpan window5PeakSpan = new TimeSpan((long)(window5PeakLocation * 10000000));
TimeSpan window10PeakSpan = new TimeSpan((long)(window10PeakLocation * 10000000));
TimeSpan chapterMaxFrameSpan = new TimeSpan((long)(chapterMaxFrameLocation * 10000000));
TimeSpan chapterStartSpan = new TimeSpan((long)(chapterStart * 10000000));
TimeSpan chapterEndSpan = new TimeSpan((long)(chapterEnd * 10000000));
TimeSpan 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 += string.Format(
"{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("{0:D1}:{1:D2}:{2:D2}.{3:D3}", chapterStartSpan.Hours, chapterStartSpan.Minutes, chapterStartSpan.Seconds, chapterStartSpan.Milliseconds),
string.Format("{0:D1}:{1:D2}:{2:D2}.{3:D3}", chapterLengthSpan.Hours, chapterLengthSpan.Minutes, chapterLengthSpan.Seconds, chapterLengthSpan.Milliseconds),
string.Format("{0:N0} kbps", Math.Round(chapterBitrate / 1000)),
string.Format("{0:N0} kbps", Math.Round(window1PeakBitrate / 1000)),
string.Format("{0:D2}:{1:D2}:{2:D2}.{3:D3}", window1PeakSpan.Hours, window1PeakSpan.Minutes, window1PeakSpan.Seconds, window1PeakSpan.Milliseconds),
string.Format("{0:N0} kbps", Math.Round(window5PeakBitrate / 1000)),
string.Format("{0:D2}:{1:D2}:{2:D2}.{3:D3}", window5PeakSpan.Hours, window5PeakSpan.Minutes, window5PeakSpan.Seconds, window5PeakSpan.Milliseconds),
string.Format("{0:N0} kbps", Math.Round(window10PeakBitrate / 1000)),
string.Format("{0:D2}:{1:D2}:{2:D2}.{3:D3}", window10PeakSpan.Hours, window10PeakSpan.Minutes, window10PeakSpan.Seconds, window10PeakSpan.Milliseconds),
string.Format("{0:N0} bytes", chapterAvgFrameSize),
string.Format("{0:N0} bytes", chapterMaxFrameSize),
string.Format("{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 += "\r\n";
report += "STREAM DIAGNOSTICS:\r\n";
report += "\r\n";
report += string.Format(
"{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 += string.Format(
"{0,-16}{1,-16}{2,-16}{3,-16}{4,-24}{5,-24}{6,-24}{7,-16}{8,-16}\r\n",
"----",
"---",
"----",
"-----",
"--------",
"--------------",
"--------------",
"-------------",
"-----",
"-------");
Dictionary<string, TSStreamClip> reportedClips = new Dictionary<string, TSStreamClip>();
foreach (TSStreamClip clip in playlist.StreamClips)
{
if (clip.StreamFile == null) continue;
if (reportedClips.ContainsKey(clip.Name)) continue;
reportedClips[clip.Name] = clip;
string clipName = clip.DisplayName;
if (clip.AngleIndex > 0)
{
clipName += string.Format(" ({0})", clip.AngleIndex);
}
foreach (TSStream clipStream in clip.StreamFile.Streams.Values)
{
if (!playlist.Streams.ContainsKey(clipStream.PID)) continue;
TSStream playlistStream =
playlist.Streams[clipStream.PID];
string clipBitRate = "0";
string clipSeconds = "0";
if (clip.StreamFile.Length > 0)
{
clipSeconds =
clip.StreamFile.Length.ToString("F3");
clipBitRate = Math.Round(
(double)clipStream.PayloadBytes * 8 /
clip.StreamFile.Length / 1000).ToString("N0");
}
string language = "";
if (playlistStream.LanguageCode != null &&
playlistStream.LanguageCode.Length > 0)
{
language = string.Format(
"{0} ({1})", playlistStream.LanguageCode, playlistStream.LanguageName);
}
report += string.Format(
"{0,-16}{1,-16}{2,-16}{3,-16}{4,-24}{5,-24}{6,-24}{7,-16}{8,-16}\r\n",
clipName,
string.Format("{0} (0x{1:X})", clipStream.PID, clipStream.PID),
string.Format("0x{0:X2}", (byte)clipStream.StreamType),
clipStream.CodecShortName,
language,
clipSeconds,
clipBitRate,
clipStream.PayloadBytes.ToString("N0"),
clipStream.PacketCount.ToString("N0"));
}
}
}
report += "\r\n";
report += "[/code]\r\n";
report += "<---- END FORUMS PASTE ---->\r\n";
report += "\r\n";
if (BDInfoSettings.GenerateTextSummary)
{
report += "QUICK SUMMARY:\r\n\r\n";
report += summary;
report += "\r\n";
}
if (BDInfoSettings.AutosaveReport && reportFile != null)
{
try { reportFile.Write(report); }
catch { }
}
textBoxReport.Text += report;
report = "";
GC.Collect();
}
if (BDInfoSettings.AutosaveReport && reportFile != null)
{
try { reportFile.Write(report); }
catch { }
}
textBoxReport.Text += report;
if (reportFile != null)
{
reportFile.Close();
}
textBoxReport.Select(0, 0);
comboBoxPlaylist.SelectedIndex = 0;
comboBoxChartType.SelectedIndex = 0;
}
public QuickReportData Generate(
BDROM BDROM,
List <TSPlaylistFile> playlists,
ScanBDROMResult scanResult,
String savePath = null
)
{
var summary = new QuickReportData();
if (!string.IsNullOrEmpty(BDROM.DiscTitle))
{
summary.DiscTitle = BDROM.DiscTitle;
}
summary.VolumeLabel = BDROM.VolumeLabel;
summary.Size = BDROM.Size;
summary.Protection = (BDROM.IsBDPlus ? "BD+" : BDROM.IsUHD ? "AACS2" : "AACS");
summary.Playlists = new List <PlaylistReport>();
foreach (var playlist in playlists)
{
var playlistSummary = new PlaylistReport();
playlistSummary.VideoStreams = new List <StreamReport>();
playlistSummary.AudioStreams = new List <StreamReport>();
playlistSummary.GraphicsStreams = new List <StreamReport>();
playlistSummary.Name = playlist.Name;
playlistSummary.Size = playlist.TotalSize;
playlistSummary.Length = new TimeSpan((long)(playlist.TotalLength * 10000000));
playlistSummary.Bitrate = playlist.TotalBitRate;
foreach (var stream in playlist.SortedStreams)
{
var streamSummary = new StreamReport();
streamSummary.CodecName = stream.CodecName;
if (stream.AngleIndex > 0)
{
streamSummary.AngleIndex = stream.AngleIndex;
streamSummary.ActiveBitrate = stream.ActiveBitRate;
}
streamSummary.Bitrate = stream.BitRate;
streamSummary.Description = stream.Description;
streamSummary.LanguageName = stream.LanguageName;
streamSummary.IsHidden = stream.IsHidden;
if (stream.IsVideoStream)
{
streamSummary.Type = "Video";
playlistSummary.VideoStreams.Add(streamSummary);
}
else if (stream.IsAudioStream)
{
streamSummary.Type = "Audio";
playlistSummary.AudioStreams.Add(streamSummary);
}
else if (stream.IsGraphicsStream)
{
streamSummary.Type = "Subtitle";
playlistSummary.GraphicsStreams.Add(streamSummary);
}
streamSummary.StreamInfo = StreamInfo.FromStream(stream);
}
summary.Playlists.Add(playlistSummary);
}
return(summary);
}
private void InitBDROMWork(
object sender,
DoWorkEventArgs e)
{
try
{
BDROM = new BDROM((string)e.Argument);
BDROM.StreamClipFileScanError += new BDROM.OnStreamClipFileScanError(BDROM_StreamClipFileScanError);
BDROM.StreamFileScanError += new BDROM.OnStreamFileScanError(BDROM_StreamFileScanError);
BDROM.PlaylistFileScanError += new BDROM.OnPlaylistFileScanError(BDROM_PlaylistFileScanError);
BDROM.Scan();
e.Result = null;
}
catch (Exception ex)
{
e.Result = ex;
}
}
private void OkButtonClick(object sender, RoutedEventArgs e)
{
if (SelectedTitle.SelectedIndex < 0) return;
if (EncodingProfile.SelectedIndex < 0) return;
JobInfo.JobName = FileTitle.Text;
TreeNode selected = (TreeNode)SelectedTitle.SelectedItem;
IEnumerable<TreeNode> sortedList = GetCheckedItems(selected);
bool videoSet = false;
foreach (TreeNode item in sortedList)
{
if (item.Data == null) continue;
Type dataType = item.Data.GetType();
if (dataType == typeof (string))
JobInfo.InputFile = (string) item.Data;
else if (dataType == typeof (VideoInfo))
{
if (!videoSet)
{
JobInfo.VideoStream = (VideoInfo) item.Data;
videoSet = true;
}
}
else if (dataType == typeof (StereoVideoInfo))
JobInfo.StereoVideoStream = (StereoVideoInfo) item.Data;
else if (dataType == typeof (AudioInfo))
JobInfo.AudioStreams.Add((AudioInfo) item.Data);
else if (dataType == typeof (SubtitleInfo))
{
SubtitleInfo sub = (SubtitleInfo) item.Data;
if ((sub.Format == "PGS" || sub.Format == "VobSub") && (_bdInfo != null && !_bdInfo.Is3D))
// don't extract subtitles on 3d blurays, because eac3to can't handle them
JobInfo.SubtitleStreams.Add(sub);
}
else if (dataType == typeof (List<TimeSpan>))
JobInfo.Chapters.AddRange((List<TimeSpan>) item.Data);
else if (dataType == typeof (Dictionary<string, object>))
{
object itemData;
(item.Data as Dictionary<string, object>).TryGetValue("Name", out itemData);
if (itemData != null)
JobInfo.InputFile = (string) itemData;
(item.Data as Dictionary<string, object>).TryGetValue("PlaylistIndex", out itemData);
if (itemData != null)
JobInfo.StreamId = (int) itemData;
(item.Data as Dictionary<string, object>).TryGetValue("TrackID", out itemData);
if (itemData != null)
JobInfo.TrackId = (int) itemData;
}
}
JobInfo.StreamId = -1;
if (_profiles != null)
{
QuickSelectProfile encProfile = (QuickSelectProfile)EncodingProfile.SelectedItem;
EncoderProfile videoEncoder = GetProfile(encProfile.VideoProfile, encProfile.VideoProfileType);
EncoderProfile audioEncoder = GetProfile(encProfile.AudioProfile, encProfile.AudioProfileType);
JobInfo.AudioProfile = audioEncoder;
JobInfo.VideoProfile = videoEncoder;
JobInfo.EncodingProfile = encProfile;
}
AppSettings.LastSelectedProfile = (string)EncodingProfile.SelectedValue;
AppSettings.SaveSettings();
if (AppSettings.CreateXbmcInfoFile)
{
JobInfo.MovieInfo = _resultMovieData;
JobInfo.PosterImage = _resultPosterImage;
JobInfo.BackDropImage = _resultBackdropImage;
}
_bdInfo = null;
DialogResult = true;
}
