/// <summary> /// Handles the click event for the View File button /// </summary> /// <param name="sender">sender object</param> /// <param name="e">routed event</param> private void ViewFile_Click(object sender, RoutedEventArgs e) { State previous = this.currentState; this.WaitMessageText = Strings.WaitForViewFile; this.CurrentState = State.Wait; try { string filePath = this.OpenFileForInspection(); if (!string.IsNullOrEmpty(filePath)) { this.eventFile = this.client.OpenEventFile(filePath); this.fileData = new FileData(this.eventFile); this.ViewFileDataGrid.DataContext = this.fileData; // show the data this.CurrentState = State.ViewFile; } else { // user canceled the OpenFileDialog, return to previous state this.CurrentState = previous; } } catch (Exception ex) { this.ErrorMessageText = string.Format(Strings.ErrorLoadFileFailed, ex.Message); this.CurrentState = State.Error; } }
/// <summary> /// Handles the click event for the Exit button /// </summary> /// <param name="sender">sender object</param> /// <param name="e">routed event</param> private void Exit_Click(object sender, RoutedEventArgs e) { if (this.eventFile != null) { this.eventFile.Dispose(); this.eventFile = null; } this.Close(); }
/// <summary> /// Handles the click event for the Exit button /// </summary> /// <param name="sender">sender object</param> /// <param name="e">routed event</param> private void CloseFile_Click(object sender, RoutedEventArgs e) { if (this.eventFile != null) { this.eventFile.Dispose(); this.eventFile = null; } this.fileData = null; this.CurrentState = State.Welcome; }
private static Guid GetFileId(string targetAlias, KStudioClipSource clipSource) { Debug.Assert(clipSource != null); Guid value = clipSource.Id; if (value == Guid.Empty) { KStudioEventFile file = clipSource as KStudioEventFile; if (file == null) { throw new ArgumentOutOfRangeException("clipSource", "not a KStudioEventFile"); } else { // File did not have a real identifier (legacy file), so create one that is "reasonable" string fileNameUpper = file.FilePath.ToUpperInvariant(); int fullPathHash = fileNameUpper.GetHashCode(); fileNameUpper = Path.GetFileName(fileNameUpper.Reverse()); int fileNameHash = fileNameUpper.GetHashCode(); if (targetAlias == null) { value = new Guid((UInt32)fullPathHash, (UInt16)fileNameHash, (UInt16)(((UInt32)fileNameHash) >> 16), 0, 0, 0, 0, 0, 0, 0, 0); } else { string targetAliasUpper = targetAlias.ToUpperInvariant(); UInt32 targetAliasHash1 = (UInt32)targetAliasUpper.GetHashCode(); targetAliasUpper = targetAliasUpper.Reverse(); UInt32 targetAliasHash2 = (UInt32)targetAliasUpper.GetHashCode(); value = new Guid((UInt32)fullPathHash, (UInt16)fileNameHash, (UInt16)(((UInt32)fileNameHash) >> 16), (byte)targetAliasHash1, (byte)(targetAliasHash1 >> 8), (byte)(targetAliasHash1 >> 16), (byte)(targetAliasHash1 >> 24), (byte)targetAliasHash2, (byte)(targetAliasHash2 >> 8), (byte)(targetAliasHash2 >> 16), (byte)(targetAliasHash2 >> 24)); } } } return(value); }
public void SaveStreamSelection() { Debug.Assert(this.clipSource != null); if (this.fileSettingsService != null) { XElement streamsElement = null; if (this.targetAlias == null) { streamsElement = this.fileSettingsService.GetSettings(this.clipSource, "streams"); } else { streamsElement = this.fileSettingsService.GetSettings(targetAlias, this.clipSource, "streams"); } if (streamsElement != null) { streamsElement.RemoveNodes(); KStudioEventFile eventFile = this.clipSource as KStudioEventFile; if (eventFile != null) { foreach (KStudioEventStream s in eventFile.EventStreams) { EventStreamState ess = s.UserState as EventStreamState; if (ess != null) { if (ess.SelectedLivePlaybackStream != null) { XElement streamElement = new XElement("stream"); streamElement.SetAttributeValue("dataTypeId", s.DataTypeId); streamElement.SetAttributeValue("fileSemanticId", s.SemanticId); streamElement.SetAttributeValue("liveSemanticId", ess.SelectedLivePlaybackStream.SemanticId); EventStreamState ess2 = ess.SelectedLivePlaybackStream.UserState as EventStreamState; if (ess2 != null) { if (ess2.IsSelectedForTargetPlayback) { streamElement.SetAttributeValue("selected", true.ToString()); } } streamsElement.Add(streamElement); } } } } } } }
public KinectFile(string filePath) { if (string.IsNullOrEmpty(filePath)) { return; } var client = KStudio.CreateClient(); _currentKinectFile = client.OpenEventFile(filePath); _streams = new List <KinectStream>(); LoadStreams(_currentKinectFile.EventStreams); }
public TimelineMarkersCollection(string targetAlias, KStudioEventFile file) : base(targetAlias, file) { DebugHelper.AssertUIThread(); if (file != null) { foreach (KStudioMarker marker in file.Markers) { TimelineMarker markerProxy = new TimelineMarker(this, marker.RelativeTime, marker); this.Points.Add(markerProxy); } } }
/// <summary> /// Verifies that the streams selected for playback exist in the file and are capable of being played on the service /// </summary> /// <param name="client">KStudioClient which is connected to the Kinect service</param> /// <param name="filePath">Path to file that will be played back</param> /// <param name="playbackStreams">Collection of streams which have been selected for playback</param> private static void VerifyStreamsForPlayback(KStudioClient client, string filePath, IEnumerable <Guid> playbackStreams) { if (client == null) { throw new ArgumentNullException("client"); } if (!client.IsServiceConnected) { throw new InvalidOperationException(Strings.ErrorNotConnected); } if (string.IsNullOrEmpty(filePath)) { throw new ArgumentNullException("filePath"); } if (playbackStreams == null) { throw new ArgumentNullException("playbackStreams"); } // verify stream exists in the file using (KStudioEventFile file = client.OpenEventFile(filePath)) { HashSet <Guid> fileStreams = new HashSet <Guid>(); foreach (KStudioEventStream stream in file.EventStreams) { fileStreams.Add(stream.DataTypeId); } if (!fileStreams.IsSupersetOf(playbackStreams)) { Guid invalidStream = playbackStreams.First(x => !fileStreams.Contains(x)); throw new InvalidOperationException(string.Format(Strings.ErrorPlaybackStreamNotInFile, StreamSupport.ConvertStreamGuidToString(invalidStream))); } } // verify stream is supported for playback by the Kinect sensor foreach (Guid stream in playbackStreams) { KStudioEventStream eventStream = client.GetEventStream(stream, KStudioEventStreamSemanticIds.KinectDefaultSensorConsumer); if (!eventStream.IsPlaybackable) { throw new InvalidOperationException(string.Format(Strings.ErrorPlaybackStreamNotSupported, StreamSupport.ConvertStreamGuidToString(stream))); } } }
/// <summary> /// Initializes a new instance of the FileData class and sets all properties to the values found within the KStudioEventFile object /// </summary> /// <param name="eventFile">A KStudioEventFile that is currently opened for read access</param> public FileData(KStudioEventFile eventFile) { if (eventFile == null) { throw new ArgumentNullException("eventFile"); } this.FileName = eventFile.FilePath; this.PublicMetadata = eventFile.GetMetadata(KStudioMetadataType.Public); this.PersonalMetadata = eventFile.GetMetadata(KStudioMetadataType.PersonallyIdentifiableInformation); this.Streams = new ObservableCollection<StreamData>(); foreach (KStudioEventStream stream in eventFile.EventStreams) { this.Streams.Add(new StreamData(stream)); } }
/// <summary> /// Initializes a new instance of the FileData class and sets all properties to the values found within the KStudioEventFile object /// </summary> /// <param name="eventFile">A KStudioEventFile that is currently opened for read access</param> public FileData(KStudioEventFile eventFile) { if (eventFile == null) { throw new ArgumentNullException("eventFile"); } this.FileName = eventFile.FilePath; this.PublicMetadata = eventFile.GetMetadata(KStudioMetadataType.Public); this.PersonalMetadata = eventFile.GetMetadata(KStudioMetadataType.PersonallyIdentifiableInformation); this.Streams = new ObservableCollection <StreamData>(); foreach (KStudioEventStream stream in eventFile.EventStreams) { this.Streams.Add(new StreamData(stream)); } }
static void Main(string[] args) { if (args.Length < 1) { Console.WriteLine("ERROR: Missing filename"); return; } if (args.Length < 2) { Console.WriteLine("ERROR: Missing output directory"); return; } string fileName = args[0]; string outputDir = args[1]; var outputDirPath = Environment.CurrentDirectory + "/" + outputDir; if (Directory.Exists(outputDirPath)) { Directory.Delete(outputDirPath, true); } Directory.CreateDirectory(outputDirPath); Console.WriteLine(fileName); KStudioClient client = KStudio.CreateClient(); KStudioEventFile file = client.OpenEventFile(fileName); foreach (KStudioSeekableEventStream stream in file.EventStreams) { if (stream.DataTypeName.Equals("Nui Uncompressed Color")) { int width = 1920; int height = 1080; byte[] bufferYuv = new byte[width * height * 2]; uint length = stream.EventCount; for (uint i = 0; i < length; i++) { var currentEvent = stream.ReadEvent(i); currentEvent.CopyEventDataToArray(bufferYuv, 0); string filePath = outputDirPath + "/" + i.ToString("D4"); File.WriteAllBytes(filePath, bufferYuv); } } } }
/// <summary> /// Updates (add/edits) stream-level metadata in an event file /// </summary> /// <param name="client">KStudioClient to use for accessing the event file</param> /// <param name="fileName">Path to event file</param> /// <param name="streamName">Name of stream which should contain the metadata</param> /// <param name="type">Type of metadata to update (Public or Personal)</param> /// <param name="key">Key of metadata object to add/edit</param> /// <param name="value">Value of metadata object to add/edit</param> /// <returns>String which contains the updated contents of the target metadata object</returns> public static string UpdateStreamMetadata(KStudioClient client, string fileName, string streamName, KStudioMetadataType type, string key, object value) { if (client == null) { throw new ArgumentNullException("client"); } if (string.IsNullOrEmpty(fileName)) { throw new ArgumentNullException("fileName"); } if (string.IsNullOrEmpty(streamName)) { throw new ArgumentNullException("streamName"); } string metadataText = string.Empty; using (KStudioEventFile file = client.OpenEventFileForEdit(fileName)) { // find the stream in the file and alter its metadata Guid dataTypeId = StreamSupport.ConvertStreamStringToGuid(streamName); if (dataTypeId == KStudioEventStreamDataTypeIds.Null) { throw new InvalidOperationException(Strings.ErrorNullStream); } KStudioEventStream stream = file.EventStreams.FirstOrDefault(s => s.DataTypeId == dataTypeId); if (stream != null) { KStudioMetadata metadata = stream.GetMetadata(type); Metadata.AlterMetadata(metadata, key, value); metadataText = Metadata.GetMetadataAsText(metadata, type, stream.DataTypeName); } } return(metadataText); }
/// <summary> /// Updates (adds/edits) file-level metadata in an event file /// </summary> /// <param name="client">KStudioClient to use for accessing the event file</param> /// <param name="fileName">Path to event file</param> /// <param name="type">Type of metadata (Public or Personal)</param> /// <param name="key">Key of metadata object to add/edit</param> /// <param name="value">Value of metadata object to add/edit</param> /// <returns>String which contains the updated contents of the target metadata object</returns> public static string UpdateFileMetadata(KStudioClient client, string fileName, KStudioMetadataType type, string key, object value) { if (client == null) { throw new ArgumentNullException("client"); } if (string.IsNullOrEmpty(fileName)) { throw new ArgumentNullException("fileName"); } string metadataText = string.Empty; using (KStudioEventFile file = client.OpenEventFileForEdit(fileName)) { KStudioMetadata metadata = file.GetMetadata(type); Metadata.AlterMetadata(metadata, key, value); metadataText = Metadata.GetMetadataAsText(metadata, type, string.Empty); } return(metadataText); }
public WritableMetadataProxy(KStudioEventFile file, KStudioEventStream stream, KStudioMetadata metadata) { DebugHelper.AssertUIThread(); if (stream == null) { throw new ArgumentNullException("stream"); } if (metadata == null) { throw new ArgumentNullException("metadata"); } this.file = file as KStudioWritableEventFile; this.stream = stream; this.metadata = metadata; this.metadata.CollectionChanged += Notify_CollectionChanged; lock (this.metadata) { LoadCollection(); } }
/// <summary> /// Handles the click event for the 'Compare Files' button /// </summary> /// <param name="sender">sender object</param> /// <param name="e">routed event args</param> private void CompareFiles_Click(object sender, RoutedEventArgs e) { State previous = this.currentState; this.WaitMessageText = Strings.WaitForCompareFiles; this.CurrentState = State.Wait; string file1 = string.Empty; string file2 = string.Empty; KStudioEventFile eventFile2 = null; try { // open the first file, if not already opened for View if (this.fileData == null) { // open a new file file1 = this.OpenFileForInspection(); // if user cancels from OpenFileDialog, return to previous state if (string.IsNullOrEmpty(file1)) { this.CurrentState = previous; return; } } // open a second file to compare with the first file2 = this.OpenFileForInspection(); // if the user cancels from OpenFileDialog, return to the previous state if (string.IsNullOrEmpty(file2)) { this.CurrentState = previous; return; } // create a FileData object for the first file, unless one already exists if (this.fileData == null) { this.eventFile = this.client.OpenEventFile(file1); this.fileData = new FileData(this.eventFile); } // create a second FileData object for comparison eventFile2 = this.client.OpenEventFile(file2); FileData fileData2 = new FileData(eventFile2); // compare data between files CompareFileData compareData = new CompareFileData(this.fileData, fileData2); this.ViewCompareFileDataGrid.DataContext = compareData; // show comparison data this.CurrentState = State.Compare; } catch (Exception ex) { this.ErrorMessageText = string.Format(Strings.ErrorCompareFilesFailed, ex.Message); this.CurrentState = State.Error; } finally { if (eventFile2 != null) { eventFile2.Dispose(); eventFile2 = null; } } }
/// <summary> /// Handles all command-line arguments /// </summary> /// <param name="args">Arguments array</param> /// <returns>CommandLineResult to indicate if the operation was successful or not</returns> private CommandLineResult ProcessCommandLine(string[] args) { string logFile = string.Empty; List <string> streamList = new List <string>(); bool updatePersonalMetadata = false; uint loopCount = 0; Dictionary <string, List <string> > commands = new Dictionary <string, List <string> >(); try { if (args == null) { return(CommandLineResult.Succeeded); } if (args.Length == 0) { return(CommandLineResult.Succeeded); } // gather commands and support parameters for (int i = 0; i < args.Length; i++) { string arg = args[i]; if (this.IsArgument(arg)) { string key = arg.Substring(1).ToUpperInvariant(); if (!commands.ContainsKey(key)) { commands.Add(key, new List <string>()); for (int j = i + 1; j < args.Length; j++) { string param = args[j]; if (!this.IsArgument(param)) { commands[key].Add(param); } else { break; } } } } } // process all command args if (commands.ContainsKey("?") || commands.ContainsKey(Strings.Command_Help)) { this.RunCommandLine(); this.ShowCommandLineHelp(); return(CommandLineResult.SucceededExit); } // -log <filename> if (commands.ContainsKey(Strings.Command_Log)) { if (commands[Strings.Command_Log].Count != 1) { Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Log)); return(CommandLineResult.Invalid); } logFile = commands[Strings.Command_Log][0]; } // -loop <count> if (commands.ContainsKey(Strings.Command_Loop)) { if (commands[Strings.Command_Loop].Count != 1) { Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Loop)); return(CommandLineResult.Invalid); } if (!uint.TryParse(commands[Strings.Command_Loop][0], out loopCount)) { Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Loop)); return(CommandLineResult.Invalid); } } // -pii if (commands.ContainsKey(Strings.Command_PII)) { updatePersonalMetadata = true; } // -stream <stream1> <stream2> <stream3> ... if (commands.ContainsKey(Strings.Command_Stream)) { if (commands[Strings.Command_Stream].Count == 0) { Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Stream)); return(CommandLineResult.Invalid); } streamList = commands[Strings.Command_Stream]; } // -view <filename> if (commands.ContainsKey(Strings.Command_View)) { this.RunCommandLine(); if (commands[Strings.Command_View].Count != 1) { Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_View)); return(CommandLineResult.Invalid); } string fileInfo = string.Empty; string filePath = commands[Strings.Command_View][0]; this.CheckFile(filePath); Console.WriteLine(Strings.WaitForViewFile); using (KStudioClient client = KStudio.CreateClient()) { if (filePath.ToUpperInvariant().StartsWith(Strings.ConsoleClipRepository.ToUpperInvariant())) { client.ConnectToService(); } using (KStudioEventFile eventFile = client.OpenEventFile(filePath)) { FileData data = new FileData(eventFile); fileInfo = data.GetFileDataAsText(); Console.WriteLine(fileInfo); } } if (!string.IsNullOrEmpty(logFile)) { Logger.Start(logFile, true); Logger.Log(fileInfo); Logger.Stop(); } Console.WriteLine(Strings.Done); return(CommandLineResult.SucceededExit); } // -compare <filename1> <filename2> if (commands.ContainsKey(Strings.Command_Compare)) { this.RunCommandLine(); if (commands[Strings.Command_Compare].Count != 2) { Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Compare)); return(CommandLineResult.Invalid); } string fileInfo = string.Empty; string file1 = commands[Strings.Command_Compare][0]; string file2 = commands[Strings.Command_Compare][1]; this.CheckFile(file1); this.CheckFile(file2); Console.WriteLine(Strings.WaitForCompareFiles); using (KStudioClient client = KStudio.CreateClient()) { if (file1.ToUpperInvariant().StartsWith(Strings.ConsoleClipRepository.ToUpperInvariant()) || file2.ToUpperInvariant().StartsWith(Strings.ConsoleClipRepository.ToUpperInvariant())) { client.ConnectToService(); } using (KStudioEventFile eventFile1 = client.OpenEventFile(file1)) using (KStudioEventFile eventFile2 = client.OpenEventFile(file2)) { FileData fileData1 = new FileData(eventFile1); FileData fileData2 = new FileData(eventFile2); CompareFileData compareData = new CompareFileData(fileData1, fileData2); fileInfo = compareData.GetCompareFileDataAsText(); Console.WriteLine(fileInfo); } } if (!string.IsNullOrEmpty(logFile)) { Logger.Start(logFile, true); Logger.Log(fileInfo); Logger.Stop(); } Console.WriteLine(Strings.Done); return(CommandLineResult.SucceededExit); } // -update <filename> <metadata key> <metadata value> if (commands.ContainsKey(Strings.Command_Update)) { this.RunCommandLine(); if (commands[Strings.Command_Update].Count != 3) { Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Update)); return(CommandLineResult.Invalid); } string filePath = commands[Strings.Command_Update][0]; string key = commands[Strings.Command_Update][1]; object value = commands[Strings.Command_Update][2]; this.CheckFile(filePath); string metadataText = string.Empty; if (streamList.Count > 0) { // update stream metadata foreach (string streamName in streamList) { Console.WriteLine(string.Format(CultureInfo.CurrentCulture, Strings.UpdatingStreamMetadata, streamName)); metadataText = this.EditMetadata(filePath, key, value, streamName, updatePersonalMetadata, true); Console.WriteLine(metadataText); } } else { // update file metadata Console.WriteLine(Strings.UpdatingFileMetadata); metadataText = this.EditMetadata(filePath, key, value, string.Empty, updatePersonalMetadata, false); Console.WriteLine(metadataText); } Console.WriteLine(Strings.Done); return(CommandLineResult.SucceededExit); } // -remove <filename> <metadata key> if (commands.ContainsKey(Strings.Command_Remove)) { this.RunCommandLine(); if (commands[Strings.Command_Remove].Count != 2) { Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Remove)); return(CommandLineResult.Invalid); } string filePath = commands[Strings.Command_Remove][0]; string key = commands[Strings.Command_Remove][1]; this.CheckFile(filePath); string metadataText = string.Empty; if (streamList.Count > 0) { // update stream metadata foreach (string streamName in streamList) { Console.WriteLine(string.Format(CultureInfo.CurrentCulture, Strings.UpdatingStreamMetadata, streamName)); metadataText = this.EditMetadata(filePath, key, null, streamName, updatePersonalMetadata, true); Console.WriteLine(metadataText); } } else { // update file metadata Console.WriteLine(Strings.UpdatingFileMetadata); metadataText = this.EditMetadata(filePath, key, null, string.Empty, updatePersonalMetadata, false); Console.WriteLine(metadataText); } Console.WriteLine(Strings.Done); return(CommandLineResult.SucceededExit); } // -play <filename> if (commands.ContainsKey(Strings.Command_Play)) { this.RunCommandLine(); if (commands[Strings.Command_Play].Count != 1) { Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Play)); return(CommandLineResult.Invalid); } string filePath = commands[Strings.Command_Play][0]; this.CheckFile(filePath); using (KStudioClient client = KStudio.CreateClient()) { Console.WriteLine(Strings.WaitToConnect); client.ConnectToService(); Console.WriteLine(Strings.StartPlayback); Playback.PlaybackClip(client, filePath, streamList, loopCount); Console.WriteLine(Strings.StopPlayback); client.DisconnectFromService(); } Console.WriteLine(Strings.Done); return(CommandLineResult.SucceededExit); } // -record <filename> <duration> if (commands.ContainsKey(Strings.Command_Record)) { this.RunCommandLine(); if (commands[Strings.Command_Record].Count != 2) { Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Record)); return(CommandLineResult.Invalid); } string filePath = commands[Strings.Command_Record][0]; this.CheckDirectory(filePath); double time = 0; if (!double.TryParse(commands[Strings.Command_Record][1], out time)) { Console.Error.WriteLine(string.Format(Strings.ErrorInvalidArgs, Strings.Command_Record)); return(CommandLineResult.Invalid); } TimeSpan duration = TimeSpan.FromSeconds(time); string errorMsg = string.Empty; string fileInfo = string.Empty; using (KStudioClient client = KStudio.CreateClient()) { Console.WriteLine(Strings.WaitToConnect); client.ConnectToService(); Console.WriteLine(Strings.StartRecording); Recording.RecordClip(client, filePath, duration, streamList); Console.WriteLine(Strings.StopRecording); using (KStudioEventFile eventFile = client.OpenEventFile(filePath)) { FileData fileData = new FileData(eventFile); fileInfo = fileData.GetFileDataAsText(); Console.WriteLine(fileInfo); } client.DisconnectFromService(); } if (!string.IsNullOrEmpty(logFile)) { Logger.Start(logFile, true); Logger.Log(fileInfo); Logger.Stop(); } Console.WriteLine(Strings.Done); return(CommandLineResult.SucceededExit); } } catch (Exception ex) { string errorMsg = string.Format(Strings.ErrorPrepend, ex.Message); Console.Error.WriteLine(errorMsg); return(CommandLineResult.Failed); } return(CommandLineResult.Invalid); }