private void DropStream(DragEventArgs e)
{
StreamTreeNode streamTreeNode = e.Data.GetData(DragDropDataName.StreamTreeNode) as StreamTreeNode;
if (streamTreeNode != null)
{
// Get the mouse position
Point mousePosition = e.GetPosition(this.Items);
// Get the visualization panel (if any) that the mouse is above
VisualizationPanel visualizationPanel = this.GetVisualizationPanelUnderMouse(mousePosition);
// Get the type of messages in the stream
Type dataType = VisualizationContext.Instance.GetDataType(streamTreeNode);
// Get the list of commands that are compatible with the user dropping the stream here
List <VisualizerMetadata> metadatas = this.GetStreamDropCommands(dataType, visualizationPanel);
// If there's any compatible visualization commands, select the most appropriate one and execute it
if (metadatas.Count > 0)
{
VisualizationContext.Instance.VisualizeStream(streamTreeNode, VisualizerMetadata.GetClosestVisualizerMetadata(dataType, metadatas), visualizationPanel);
}
}
}
private void DropStream(DragEventArgs e)
{
StreamTreeNode streamTreeNode = e.Data.GetData(DragDropDataName.StreamTreeNode) as StreamTreeNode;
if (streamTreeNode != null)
{
// Get the mouse position
Point mousePosition = e.GetPosition(this.Items);
// Get the visualization panel (if any) that the mouse is above
VisualizationPanel visualizationPanel = this.GetVisualizationPanelUnderMouse(mousePosition);
// Get the type of messages in the stream
Type dataType = VisualizationContext.Instance.GetDataType(streamTreeNode.NodeTypeName);
// Get the list of commands that are compatible with the user dropping the stream here
var visualizers = VisualizationContext.Instance.PluginMap.GetCompatibleVisualizers(
streamTreeNode, visualizationPanel, isUniversal: false, isInNewPanel: false);
// If there's any compatible visualization commands, select the most appropriate one and execute it
if (visualizers.Any())
{
VisualizationContext.Instance.VisualizeStream(streamTreeNode, VisualizerMetadata.GetClosestVisualizerMetadata(dataType, visualizers), visualizationPanel);
}
}
}
public void CheckSubItems(StreamTreeNode node)
{
foreach (var childNode in node.Children)
{
childNode.IsChecked = node.IsChecked;
childNode.IsExpanded = node.IsChecked;
}
node.IsExpanded = node.IsChecked;
}
private List <VisualizerMetadata> GetStreamDropCommands(StreamTreeNode streamTreeNode, VisualizationPanel visualizationPanel)
{
List <VisualizerMetadata> metadatas = new List <VisualizerMetadata>();
// Get all the commands that are applicable to this stream tree node and the panel it was dropped over
Type streamType = VisualizationContext.Instance.GetStreamType(streamTreeNode);
metadatas = VisualizationContext.Instance.VisualizerMap.GetByDataTypeAndPanelAboveSeparator(streamType, visualizationPanel);
return(metadatas);
}
public StreamTreeNode CreateNode(StreamTreeNode tParent, string tName, object data)
{
var subNode = new StreamTreeNode
{
ID = _treeNodeID++,
Name = tName,
Data = data,
IsChecked = tParent.IsChecked,
IsExpanded = tParent.IsExpanded,
Parent = tParent,
Children = new List <StreamTreeNode>()
};
subNode.PropertyChanged += TreeNodePropertyChanged;
tParent.Children.Add(subNode);
return(subNode);
}
private void Items_DragOver(object sender, DragEventArgs e)
{
string dragOperation = e.Data.GetData(DragDropDataName.DragDropOperation) as string;
if (dragOperation == DragDropOperation.ReorderPanel)
{
this.dragDropAdorner.SetPanelLocation(e.GetPosition(this.Items));
this.Cursor = Cursors.Hand;
e.Handled = true;
}
else if (dragOperation == DragDropOperation.DragDropStream)
{
StreamTreeNode streamTreeNode = e.Data.GetData(DragDropDataName.StreamTreeNode) as StreamTreeNode;
Point mousePosition = e.GetPosition(this.Items);
List <VisualizerMetadata> metadatas = this.GetStreamDropCommands(streamTreeNode, this.GetVisualizationPanelUnderMouse(mousePosition));
e.Effects = metadatas.Count > 0 ? DragDropEffects.Move : DragDropEffects.None;
e.Handled = true;
}
}
public IEnumerable <StreamTreeNode> GetCheckedItems(StreamTreeNode streamTree)
{
var items = new List <StreamTreeNode>();
if (streamTree.IsChecked)
{
items.Add(streamTree);
}
if (streamTree.Children.Count <= 0)
{
return(items);
}
foreach (var child in streamTree.Children)
{
items.AddRange(GetCheckedItems(child));
}
return(items);
}
private void Items_DragOver(object sender, DragEventArgs e)
{
string dragOperation = e.Data.GetData(DragDropDataName.DragDropOperation) as string;
if (dragOperation == DragDropOperation.ReorderPanel)
{
this.dragDropAdorner.SetPanelLocation(e.GetPosition(this.Items));
this.Cursor = Cursors.Hand;
e.Handled = true;
}
else if (dragOperation == DragDropOperation.DragDropStream)
{
StreamTreeNode streamTreeNode = e.Data.GetData(DragDropDataName.StreamTreeNode) as StreamTreeNode;
Point mousePosition = e.GetPosition(this.Items);
var visualizers = VisualizationContext.Instance.PluginMap.GetCompatibleVisualizers(
streamTreeNode, this.GetVisualizationPanelUnderMouse(mousePosition), isUniversal: false, isInNewPanel: false);
e.Effects = visualizers.Any() ? DragDropEffects.Move : DragDropEffects.None;
e.Handled = true;
}
}
public void CheckRootItem(StreamTreeNode item)
{
var iParent = item.Parent;
StreamTreeNode topParent = null;
if (iParent != null)
{
item.IsChecked = true;
item.IsExpanded = true;
iParent.IsChecked = true;
iParent.IsExpanded = true;
topParent = iParent.Parent;
}
if (topParent == null)
{
return;
}
topParent.IsExpanded = true;
topParent.IsChecked = true;
}
private void StreamTreeNode_MouseMove(object sender, System.Windows.Input.MouseEventArgs e)
{
// If the left button is also pressed, then the user is probably wanting to
// initiate a drag operation of the stream into the Visualization Container
if (e.LeftButton == MouseButtonState.Pressed)
{
// Get the Tree Item that sent the event
StackPanel treeNode = sender as StackPanel;
if (treeNode != null)
{
StreamTreeNode streamTreeNode = treeNode.DataContext as StreamTreeNode;
if (streamTreeNode != null && streamTreeNode.CanVisualize)
{
// Begin the Drag & Drop operation
DataObject data = new DataObject();
data.SetData(DragDropDataName.DragDropOperation, DragDropOperation.DragDropStream);
data.SetData(DragDropDataName.StreamTreeNode, streamTreeNode);
DragDrop.DoDragDrop(treeNode, data, DragDropEffects.Move);
}
}
}
}
public void GetBdInfo()
{
const string strChapters = "Chapters"; //ProcessingService.GetResourceString("streamselect_chapters");
const string strVideo = "Video"; //ProcessingService.GetResourceString("streamselect_video");
const string strAudio = "Audio"; //ProcessingService.GetResourceString("streamselect_audio");
const string strSubtitles = "Subtitles"; //ProcessingService.GetResourceString("streamselect_subtitles");
_bdInfo = new BDROM(JobInfo.InputFile);
_bdInfo.Scan();
var longestClip = GetLongestBdPlaylist();
var playlistIndex = 1;
foreach (var item in _bdInfo.PlaylistFiles.Values)
{
if (!item.IsValid)
{
playlistIndex++;
continue;
}
var streamIndex = 0;
var duration = new DateTime();
duration = duration.AddSeconds(item.TotalLength);
var treeRoot = $"Title: {playlistIndex:0} ({item.Name}), Length: {duration.ToString("H:mm:ss.fff")}";
var treeData = new Dictionary <string, object>
{
{
"Name",
Path.Combine(_bdInfo.DirectoryPLAYLIST.FullName, item.Name)
},
{ "PlaylistIndex", playlistIndex }
};
var root = new StreamTreeNode
{
ID = _treeNodeID++,
Name = treeRoot,
Data = treeData,
Children = new List <StreamTreeNode>(),
IsChecked = true,
IsExpanded = true
};
root.PropertyChanged += TreeNodePropertyChanged;
_tree.Add(root);
var chaptersStreamTree = CreateNode(root, strChapters, null);
var videoStreamTree = CreateNode(root, strVideo, null);
var audioStreamTree = CreateNode(root, strAudio, null);
var subStreamTree = CreateNode(root, strSubtitles, null);
var streamChapters = new List <TimeSpan>();
if (item.Chapters.Count > 1)
{
streamIndex++;
streamChapters.AddRange(item.Chapters.Select(TimeSpan.FromSeconds));
var chaptersFormat = $"{streamChapters.Count:0} {strChapters}";
CreateNode(chaptersStreamTree, chaptersFormat, streamChapters);
}
var videoDescStereo = string.Empty;
var leftVideoStreamID = -1;
var leftVideoDiscStreamID = -1;
foreach (var clip in item.VideoStreams)
{
streamIndex++;
var videoCodec = clip.CodecName;
var videoCodecShort = clip.CodecShortName;
var 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 += item.MVCBaseViewR ? " (right eye)" : " (left eye)";
leftVideoStreamID = streamIndex;
leftVideoDiscStreamID = clip.PID;
}
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";
videoCodec += item.MVCBaseViewR ? " (right eye)" : " (left eye)";
}
var videoStreamFormat = $"{streamIndex:0}: {videoCodec} ({videoCodecShort}), {videoDesc}";
switch (clip.StreamType)
{
case TSStreamType.AVC_VIDEO:
case TSStreamType.MPEG2_VIDEO:
case TSStreamType.MPEG1_VIDEO:
case TSStreamType.VC1_VIDEO:
{
var 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
};
int.TryParse(item.Name.Substring(0, item.Name.LastIndexOf('.')), NumberStyles.Number,
_configService.CInfo, out vid.DemuxPlayList);
foreach (var 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(videoStreamTree, videoStreamFormat, vid);
}
break;
case TSStreamType.MVC_VIDEO:
{
var vid = new StereoVideoInfo
{
RightStreamId = streamIndex,
DemuxRightStreamId = clip.PID,
LeftStreamId = leftVideoStreamID,
DemuxLeftStreamId = leftVideoDiscStreamID
};
CreateNode(videoStreamTree, videoStreamFormat, vid);
}
break;
}
}
foreach (var audio in item.AudioStreams)
{
streamIndex++;
var audioCodec = audio.CodecName;
var audioCodecShort = audio.CodecShortName;
var audioDesc = audio.Description;
var audioLangCode = audio.LanguageCode;
var audioLanguage = audio.LanguageName;
var audioStreamFormat = $"{streamIndex:0}: {audioCodec} ({audioCodecShort}) / {audioLangCode} ({audioLanguage}) / {audioDesc}";
var 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(audioStreamTree, audioStreamFormat, aud);
}
foreach (var sub in item.TextStreams)
{
streamIndex++;
var subCodecShort = sub.CodecShortName;
var subDesc = sub.Description;
var subLangCode = sub.LanguageCode;
var subLanguage = sub.LanguageName;
var subStreamFormat = $"{streamIndex:0}: {subCodecShort} / {subLangCode} ({subLanguage}); {subDesc}";
var subInfo = new SubtitleInfo
{
Id = streamIndex,
StreamId = streamIndex,
TempFile = string.Empty,
LangCode = subLangCode,
Format = subCodecShort,
Delay = 0,
DemuxStreamId = sub.PID,
StreamSize = 0
};
CreateNode(subStreamTree, subStreamFormat, subInfo);
}
foreach (var sub in item.GraphicsStreams)
{
streamIndex++;
var subCodecShort = sub.CodecShortName;
var subDesc = sub.Description;
var subLangCode = sub.LanguageCode;
var subLanguage = sub.LanguageName;
var subStreamFormat = $"{streamIndex:0}: {subCodecShort} / {subLangCode} ({subLanguage}); {subDesc}";
var subInfo = new SubtitleInfo
{
Id = streamIndex,
StreamId = streamIndex,
TempFile = string.Empty,
LangCode = subLangCode,
Format = subCodecShort,
DemuxStreamId = sub.PID,
StreamSize = 0
};
CreateNode(subStreamTree, subStreamFormat, subInfo);
}
playlistIndex++;
}
_defaultSelection = longestClip - 1;
}
public void GetFileInfo()
{
var mi = new MediaInfoContainer();
try
{
mi = GenHelper.GetMediaInfo(JobInfo.InputFile);
}
catch (TimeoutException ex)
{
Log.Error(ex);
}
JobInfo.MediaInfo = mi;
const string strChapters = "Chapters";
const string strVideo = "Video";
const string strAudio = "Audio";
const string strSubtitles = "Subtitles";
var containerFormat = mi.General.Format;
var duration = mi.General.DurationTime.ToString("H:mm:ss.fff");
var shortFileName = mi.General.FileName + "." + mi.General.FileExtension;
var treeRoot = $"{shortFileName} / {containerFormat} / Length: {duration}";
var root = new StreamTreeNode
{
ID = _treeNodeID++,
Name = treeRoot,
Data = JobInfo.InputFile,
IsChecked = true,
IsExpanded = true,
Children = new List <StreamTreeNode>()
};
root.PropertyChanged += TreeNodePropertyChanged;
_tree.Add(root);
var chaptersStreamTree = CreateNode(root, strChapters, null);
var videoStreamTree = CreateNode(root, strVideo, null);
var audioStreamTree = CreateNode(root, strAudio, null);
var subStreamTree = CreateNode(root, strSubtitles, null);
if (mi.Chapters.Count > 0)
{
var chaptersTitle = $"{mi.Chapters.Count:0} {strChapters}";
CreateNode(chaptersStreamTree, chaptersTitle, mi.Chapters);
}
else
{
chaptersStreamTree.IsChecked = false;
}
var streamIndex = 0;
foreach (var clip in mi.Video)
{
streamIndex++;
var videoPid = clip.ID;
var videoCodec = clip.FormatInfo;
var videoCodecShort = clip.Format;
var videoDesc = $"{clip.Width:0}x{clip.Height:0} {clip.ScanType} / Profile: {clip.FormatProfile} / {clip.FrameRate:0.000}fps";
var videoStreamTitle = $"{streamIndex:0}: {videoCodec} ({videoCodecShort}), {videoDesc}";
var vid = new VideoInfo();
if (JobInfo.Input == InputType.InputAvi)
{
vid.StreamId = 0;
}
else
{
vid.StreamId = videoPid == 0 ? streamIndex : videoPid;
}
vid.StreamKindID = clip.StreamKindID;
vid.Fps = clip.FrameRate;
vid.PicSize = clip.VideoSize;
vid.Interlaced = clip.ScanType == "Interlaced";
vid.Format = clip.Format;
vid.FormatProfile = clip.FormatProfile;
vid.Height = clip.Height;
vid.Width = clip.Width;
vid.FrameCount = clip.FrameCount;
vid.StreamSize = clip.StreamSize;
vid.Length = mi.General.DurationTime.TimeOfDay.TotalSeconds;
float.TryParse(clip.DisplayAspectRatio, NumberStyles.Number, _configService.CInfo, out vid.AspectRatio);
vid.FrameRateEnumerator = clip.FrameRateEnumerator;
vid.FrameRateDenominator = clip.FrameRateDenominator;
vid.FrameMode = clip.FormatFrameMode;
CreateNode(videoStreamTree, videoStreamTitle, vid);
}
videoStreamTree.IsChecked = videoStreamTree.Children.Count > 0;
foreach (var audio in mi.Audio)
{
streamIndex++;
var audioPid = audio.ID;
var audioCodec = audio.FormatInfo;
var audioCodecShort = audio.Format;
var audioLangCode = audio.LanguageIso6392;
var audioLanguage = audio.LanguageFull;
var audioStreamKindID = audio.StreamKindID;
var audioDesc = $"{audio.Channels:0} Channels ({audio.ChannelPositions}) / {audio.SamplingRate:0}Hz / ";
audioDesc += $"{audio.BitDepth:0} bit / {audio.BitRate/1000:0} kbit/s";
var audioStreamTitle = $"{streamIndex:0}: {audioCodec} ({audioCodecShort}) / {audioLangCode} ({audioLanguage}) / {audioDesc}";
if (JobInfo.Input == InputType.InputAvi)
{
audioPid += 1;
}
else
{
audioPid = audioPid == 0 ? streamIndex : audioPid;
}
var aud = new AudioInfo
{
Id = audioPid,
Format = audioCodecShort,
FormatProfile = audio.FormatProfile,
StreamId = streamIndex,
LangCode = audioLangCode,
OriginalId = audioPid,
StreamKindId = audioStreamKindID,
Delay = audio.Delay,
Bitrate = audio.BitRate,
SampleRate = audio.SamplingRate,
ChannelCount = audio.Channels,
BitDepth = audio.BitDepth,
ShortLang = audio.LanguageIso6391,
StreamSize = audio.StreamSize,
Length = mi.General.DurationTime.TimeOfDay.TotalSeconds,
IsHdStream = audio.CompressionMode == "Lossless"
};
CreateNode(audioStreamTree, audioStreamTitle, aud);
}
audioStreamTree.IsChecked = audioStreamTree.Children.Count > 0;
foreach (var sub in mi.Text)
{
streamIndex++;
var subCodec = sub.CodecIDInfo;
var subCodecShort = sub.Format;
var subLangCode = sub.LanguageIso6392;
var subLanguage = sub.LanguageFull;
var subStreamKindID = sub.StreamKindID;
var subStreamTitle = $"{streamIndex:0}: {subCodec} ({subCodecShort}) / {subLangCode} ({subLanguage})";
var subInfo = new SubtitleInfo
{
Id = sub.ID,
StreamId = streamIndex,
LangCode = subLangCode,
Format = subCodecShort,
StreamKindId = subStreamKindID,
Delay = sub.Delay,
StreamSize = sub.StreamSize
};
CreateNode(subStreamTree, subStreamTitle, subInfo);
}
foreach (var sub in mi.Image)
{
streamIndex++;
var subCodec = sub.CodecIDInfo;
var subCodecShort = sub.Format;
var subLangCode = sub.LanguageIso6392;
var subLanguage = sub.LanguageFull;
var subStreamKindID = sub.StreamKindID;
var subStreamTitle = $"{streamIndex:0}: {subCodec} ({subCodecShort}) / {subLangCode} ({subLanguage})";
var subInfo = new SubtitleInfo
{
Id = sub.ID,
StreamId = streamIndex,
LangCode = subLangCode,
Format = subCodecShort,
StreamKindId = subStreamKindID,
Delay = 0,
StreamSize = sub.StreamSize
};
CreateNode(subStreamTree, subStreamTitle, subInfo);
}
subStreamTree.IsChecked = subStreamTree.Children.Count > 0;
NotifyOfPropertyChange(() => Tree);
}
public void SetSelectedItem(StreamTreeNode myNode)
{
SelectedNode = myNode;
NotifyOfPropertyChange(() => SelectedNode);
NotifyOfPropertyChange(() => SelectedNodeData);
}
public void GetDvdTitleList()
{
const string strChapters = "Chapters";
const string strVideo = "Video";
const string strAudio = "Audio";
const string strSubtitles = "Subtitles";
var dvd = new DvdInfoContainer(JobInfo.InputFile);
foreach (var info in dvd.Titles)
{
int videoId = info.TitleNumber;
var fps = info.VideoStream.Framerate;
var videoFormat = info.VideoStream.VideoStandard.ToString();
var codec = _processingService.StringValueOf(info.VideoStream.CodingMode);
var aspect = _processingService.StringValueOf(info.VideoStream.AspectRatio);
var resolution = _processingService.StringValueOf(info.VideoStream.VideoResolution);
var resolutionArray = resolution.Split(new[] { "x" }, StringSplitOptions.RemoveEmptyEntries);
int width = 0, height = 0;
try
{
int.TryParse(resolutionArray[0], out width);
int.TryParse(resolutionArray[1], out height);
}
catch (Exception ex)
{
Log.Error(ex);
}
var letterboxed = _processingService.StringValueOf(info.VideoStream.DisplayFormat);
int vtsID = info.TitleSetNumber;
var duration = DateTime.MinValue.Add(info.VideoStream.Runtime);
var treeRoot = $"Title: {videoId:0}, Length: {duration.ToString("H:mm:ss.fff")}";
var treeData = new Dictionary <string, object>
{
{ "Name", JobInfo.InputFile },
{ "TrackID", videoId }
};
var root = new StreamTreeNode
{
ID = _treeNodeID++,
Name = treeRoot,
Data = treeData,
Children = new List <StreamTreeNode>(),
IsChecked = true,
IsExpanded = true
};
_tree.Add(root);
var chaptersTree = CreateNode(root, strChapters, null);
var videoTree = CreateNode(root, strVideo, null);
var audioTree = CreateNode(root, strAudio, null);
var subTree = CreateNode(root, strSubtitles, null);
if (info.Chapters != null && info.Chapters.Count > 0)
{
var chaptersFormat = $"{info.Chapters.Count:0} {strChapters}";
CreateNode(chaptersTree, chaptersFormat, info.Chapters);
}
var videoStream = $"{codec} {resolution} {aspect} ({letterboxed}) {videoFormat} {fps:0.000} fps";
var vid = new VideoInfo
{
VtsId = vtsID,
TrackId = videoId,
StreamId = 1,
Fps = fps,
Interlaced = true,
Format = codec,
FrameCount = 0,
Width = width,
Height = height,
Encoded = false,
IsRawStream = false,
DemuxStreamNames = new List <string>(),
StreamSize = 0,
Length = info.VideoStream.Runtime.TotalSeconds,
FrameRateEnumerator = info.VideoStream.FrameRateNumerator,
FrameRateDenominator = info.VideoStream.FrameRateDenominator,
AspectRatio = info.VideoStream.AspectRatio == DvdVideoAspectRatio.Aspect4By3 ? 4f / 3f : 16f / 9f
};
CreateNode(videoTree, videoStream, vid);
foreach (var stream in info.AudioStreams)
{
var audioID = stream.StreamIndex;
var langCode = stream.Language.Code;
var language = stream.Language.Name;
var format = _processingService.StringValueOf(stream.CodingMode);
var frequency = stream.SampleRate;
var quantization = _processingService.StringValueOf(stream.Quantization);
var channels = stream.Channels;
var content = _processingService.StringValueOf(stream.Extension);
var streamID = stream.StreamId;
var audioStream =
$"Track {audioID:0} ({streamID:0}), {langCode} ({language} - {content}), {format} {channels:0} Channels {frequency:0} Hz, {quantization}";
var aud = new AudioInfo
{
Format = format,
FormatProfile = string.Empty,
Id = audioID,
StreamId = streamID,
LangCode = langCode,
TempFile = string.Empty,
OriginalId = audioID,
Delay = 0,
Bitrate = 0,
SampleRate = frequency,
ChannelCount = channels,
ShortLang = langCode,
StreamSize = 0,
IsHdStream = false
};
CreateNode(audioTree, audioStream, aud);
}
foreach (var stream in info.SubtitleStreams)
{
var subID = stream.StreamIndex;
var langCode = stream.Language.Code;
var language = stream.Language.Name;
var content = _processingService.StringValueOf(stream.Extension);
var streamID = stream.StreamId;
var subtitleStream = $"Track {subID:0} ({streamID:0}), {langCode} ({language} - {content})";
var subInfo = new SubtitleInfo
{
Id = subID + info.AudioStreams.Count,
StreamId = streamID,
TempFile = string.Empty,
LangCode = langCode,
Format = "VobSub",
Delay = 0,
StreamSize = 0
};
CreateNode(subTree, subtitleStream, subInfo);
}
}
int longestTrack =
dvd.Titles.Single(
info => info.VideoStream.Runtime == dvd.Titles.Max(infoLocl => infoLocl.VideoStream.Runtime))
.TitleNumber;
_defaultSelection = longestTrack - 1;
}
private bool ExecuteCommandIfPresent(List <TypeKeyedActionCommand> commands, string commandName, StreamTreeNode streamTreeNode)
{
// Check if the command is in the list
TypeKeyedActionCommand command = commands.Find(o => o.DisplayName.Equals(commandName, StringComparison.Ordinal));
if (command != null)
{
VisualizationContainer visualizationContainer = this.DataContext as VisualizationContainer;
// If we're adding the stream to an existing Visualization Panel, then make sure it's the selected panel first.
// Otherwise, make sure the last current panel is selected so that the new panel is created at the bottom.
if (this.hitTestResult != null)
{
VisualizationPanel visualizationPanel = this.hitTestResult.DataContext as VisualizationPanel;
visualizationContainer.CurrentPanel = visualizationPanel;
}
else if (visualizationContainer.Panels.Count > 0)
{
visualizationContainer.CurrentPanel = visualizationContainer.Panels[visualizationContainer.Panels.Count - 1];
}
// Execute the command
command.Execute(streamTreeNode);
return(true);
}
return(false);
}
private void DropStream(DragEventArgs e)
{
StreamTreeNode streamTreeNode = e.Data.GetData(DragDropDataName.StreamTreeNode) as StreamTreeNode;
if (streamTreeNode != null)
{
// Get the list of Visualization Commands we can execute on this stream
List <TypeKeyedActionCommand> commands = PsiStudioContext.Instance.GetVisualizeStreamCommands(streamTreeNode);
// Find out if the mouse is above an existing Visualization Panel
this.hitTestResult = null;
Point pt = e.GetPosition(this.Items);
VisualTreeHelper.HitTest(
this.Items,
new HitTestFilterCallback(this.HitTestFilter),
new HitTestResultCallback(this.HitTestResultCallback),
new PointHitTestParameters(pt));
// If we're above an existing Visualization Panel and there exists some "plot" commands, then execute
// the "plot in new panel" command, otherwise execute whatever plot or visualize command we can find.
if (this.hitTestResult != null)
{
if (this.ExecuteCommandIfPresent(commands, ContextMenuName.Visualize, streamTreeNode))
{
return;
}
if (this.ExecuteCommandIfPresent(commands, ContextMenuName.VisualizeAsMilliseconds, streamTreeNode))
{
return;
}
}
else
{
if (this.ExecuteCommandIfPresent(commands, ContextMenuName.VisualizeInNewPanel, streamTreeNode))
{
return;
}
if (this.ExecuteCommandIfPresent(commands, ContextMenuName.VisualizeAsMillisecondsInNewPanel, streamTreeNode))
{
return;
}
if (this.ExecuteCommandIfPresent(commands, ContextMenuName.Visualize, streamTreeNode))
{
return;
}
if (this.ExecuteCommandIfPresent(commands, ContextMenuName.VisualizeAs2DDepth, streamTreeNode))
{
return;
}
if (this.ExecuteCommandIfPresent(commands, ContextMenuName.VisualizeAs3DDepth, streamTreeNode))
{
return;
}
if (this.ExecuteCommandIfPresent(commands, ContextMenuName.VisualizeAsPlanarDirection, streamTreeNode))
{
return;
}
}
}
}
