private void Chop(TrackEvent clip, Timecode offset) { while (clip.Length.FrameCount > 1) { clip = clip.Split(offset); } }
private void EventPropertiesMarkersCopy_Invoked(object sender, EventArgs e) { var markers = new Dictionary <double, string>(); List <TrackEvent> selected = myVegas.Project.GetSelectedEvents(true); if (selected.Count == 0) { return; } TrackEvent selectedEvent = selected[0]; if (!selectedEvent.IsAudio()) { return; } Media media = selectedEvent.ActiveTake.Media; foreach (MediaMarker mk in media.Markers) { double posSeconds = (double)mk.Position.Nanos / 10000000; // ONE BILLION DOLLARS markers.Add(posSeconds, mk.Label); } Clipboard.SetData(Strings.ClipboardMarkersTag, markers); }
private void PosAlignByMarkers() { var selectedByTrack = myVegas.Project.GetSelectedEvents().GroupBy(item => item.Track); if (selectedByTrack.Count() < 2) { return; } var guideEvents = selectedByTrack.First(); var punchpoints = (guideEvents.Select(Ev => new { Ev, mmk = Ev.FindCurrentMetaMarker() }).Select(T => T.Ev.Start + T.mmk.GlobalMarkerOffset)).ToList(); selectedByTrack = selectedByTrack.Skip(1); // don't adjust the guide track using (var undo = new UndoBlock("Align by markers")) { foreach (var group in selectedByTrack) { var events = new List <TrackEvent>(); events.AddRange(group); for (int i = 0; i <= events.Count - 1; i++) { if (i > punchpoints.Count - 1) { break; } TrackEvent ev = events[i]; MetaMarker mmk = ev.FindCurrentMetaMarker(); Timecode newMkPos = punchpoints[i]; ev.Start = newMkPos - mmk.GlobalMarkerOffset; } } } }
internal void RaiseTrackEvent(string eventName, string serializedJson) { Contracts.AssertNonEmpty(eventName); Contracts.AssertNonEmpty(serializedJson); TrackEvent?.Invoke(this, new TrackEventArgs(eventName, serializedJson)); }
private VideoEvent createText(Media media, VideoTrack track, TrackEvent eventBelow) { VideoEvent txtEvent = track.AddVideoEvent(eventBelow.Start, eventBelow.End - eventBelow.Start); Take take = txtEvent.AddTake(media.GetVideoStreamByIndex(0)); return(txtEvent); }
void CreateCrossFades(TrackEvent trackEvent, Track track, Timecode halfCrossFade) { if (trackEvent.Index >= 1) // Check current event and the previous one { var previousEvent = track.Events[trackEvent.Index - 1]; if (previousEvent.End == trackEvent.Start) // If they form a straight cut expand margins { ExpandRightMargin(previousEvent, halfCrossFade, Settings.AllowLoops); ExpandLeftMargin(trackEvent, halfCrossFade, Settings.AllowLoops); if (Settings.ChangeCurveType) { ApplyCurves(trackEvent); } } } if (trackEvent.Index < track.Events.Count - 1) // Check current event and the next one { var nextEvent = track.Events[trackEvent.Index + 1]; if (trackEvent.End == nextEvent.Start) // If they form a straight cut expand margins { ExpandRightMargin(trackEvent, halfCrossFade, Settings.AllowLoops); ExpandLeftMargin(nextEvent, halfCrossFade, Settings.AllowLoops); if (Settings.TransitionMode == TransitionMode.AddTransition && nextEvent.IsVideo()) { AddTransition(nextEvent); } if (Settings.ChangeCurveType) { ApplyCurves(nextEvent); } } } }
public List <TrackEvent> CutFirstGroup() { List <TrackEvent> trackEvents = new List <TrackEvent>(); List <TrackEvent> trackEventsInGroup = new List <TrackEvent>(); foreach (TrackEvent trackEvent in group1) { trackEventsInGroup.Add(trackEvent); } foreach (TrackEvent trackEvent in trackEventsInGroup) { Timecode offset = trackEvent.Length - new Timecode(Config.splitOffset); TrackEvent cut = null; using (UndoBlock undo = new UndoBlock("Cut first group track events")) { cut = trackEvent.Split(offset); } if (cut != null) { trackEvents.Add(cut); } } return(trackEvents); }
public async Task <Unit> Handle(Command request, CancellationToken cancellationToken) { var trackEvent = new TrackEvent { Id = request.Id, JobId = request.jobId, JobName = request.jobName, UserId = request.userId, Event = request.eventTracked, Source = request.source, ActionDate = request.actionDate, RemoteIP = request.remoteIP, RequestProperties = request.requestProperties, RemoteResponse = "" }; _context.TrackEvents.Add(trackEvent); //handler logic var success = await _context.SaveChangesAsync(false) > 0; if (success) { return(Unit.Value); } throw new Exception("problem saving changes"); }
// skip audio events that are grouped with a selected video event // that uses the same media because they usually contain the same // captioning data private bool IsPairedAudioEvent(TrackEvent trackEvent, Media media) { if (trackEvent.IsAudio() && trackEvent.IsGrouped) { TrackEventGroup group = trackEvent.Group; if (null != group) { foreach (TrackEvent groupedEvent in group) { if (groupedEvent != trackEvent) { if (groupedEvent.IsVideo() && groupedEvent.Selected) { Take take = groupedEvent.ActiveTake; if (null != take) { Media groupedMedia = take.Media; if (null != media) { if (groupedMedia == media) { return(true); } } } } } } } } return(false); }
private void PrintTrackName(object sender, TrackEvent args) { if (session.isHosting) { connection.SetTrack(args); } }
public void RemoveEvent(TrackEvent Event) { if (_Events.Contains(Event)) { _Events.Remove(Event); } }
private void OnEventChanged(TrackEvent trackEvent) { if (EventChanged != null) { EventChanged(trackEvent); } }
private void SplitEvent() { List <TrackEvent> Events = myVegas.Project.GetSelectedEvents(); if (Events.Count == 0) { return; } using (var undo = new UndoBlock("Split Events by MetaTakes")) { foreach (TrackEvent ev in Events) { TrackEvent curEv = ev; foreach (MediaMarker mk in ev.ActiveTake.Media.Markers) { if (curEv == null) { break; // dun goofed } var mmk = new MetaMarker(mk, curEv); if (!mmk.IsWithinEventBounds) { continue; } curEv = curEv.Split(mmk.GlobalMarkerOffset); } } } }
void AddTransition(TrackEvent trackEvent) { var newEffect = new Effect(Settings.Effect.PlugIn); trackEvent.FadeIn.Transition = newEffect; newEffect.Preset = Settings.PresetName; }
/// <summary> /// テキストイベントの文字数に応じて、イベントの長さを求めるメソッド /// https://www.pine4.net/Memo/Article/Archives/424 /// </summary> /// <param name="textEvent">変更するTrackEvent</param> /// <returns>length of event</returns> double CalculateEventLengthBasedOnWordCount(TrackEvent textEvent) { string takeName = textEvent.ActiveTake.Name.Remove(0, TitleNamePrefix.Length); IFELanguage ifelang = null; string allKanaName = String.Empty; try { ifelang = Activator.CreateInstance(Type.GetTypeFromProgID("MSIME.Japan")) as IFELanguage; int hr = ifelang.Open(); if (hr != 0) { throw Marshal.GetExceptionForHR(hr); } hr = ifelang.GetPhonetic(takeName, 1, -1, out allKanaName); ifelang.Close(); } catch (COMException ex) { if (ifelang != null) { ifelang.Close(); } } int commaNumber = CountChar(allKanaName, ',') + CountChar(allKanaName, '、'); int spaceNumber = CountChar(allKanaName, ' ') + CountChar(allKanaName, ' '); return((allKanaName.Length - commaNumber - spaceNumber) * TimePerWordCountms + commaNumber * TimePerCommams + ExtraTimems); }
void ImportTrackEvent(XmlElement parent, TrackEvents events) { TrackEvent trackEvent = null; AudioEvent audioEvent = null; VideoEvent videoEvent = null; if (parent.Name == "AudioEvent") { audioEvent = new AudioEvent(); trackEvent = (TrackEvent)audioEvent; } else if (parent.Name == "VideoEvent") { videoEvent = new VideoEvent(); trackEvent = (TrackEvent)videoEvent; } events.Add(trackEvent); try { trackEvent.Name = ChildString(parent, "Name"); } catch {} trackEvent.Start = ChildTimecode(parent, "Start"); Timecode length = ChildTimecode(parent, "Length"); if (0 >= length.Nanos) { throw new ApplicationException("invalid event length"); } trackEvent.Length = length; try { trackEvent.PlaybackRate = ChildDouble(parent, "PlaybackRate"); } catch {} try { trackEvent.Mute = ChildBoolean(parent, "Mute"); } catch {} try { trackEvent.Locked = ChildBoolean(parent, "Locked"); } catch {} try { trackEvent.Loop = ChildBoolean(parent, "Loop"); } catch {} try { trackEvent.Selected = ChildBoolean(parent, "Selected"); } catch {} if (null != audioEvent) { try { audioEvent.Normalize = ChildBoolean(parent, "Normalize"); } catch {} try { audioEvent.InvertPhase = ChildBoolean(parent, "InvertPhase"); } catch {} try { audioEvent.Channels = ChildChannelRemapping(parent, "Channels"); } catch {} } else if (null != videoEvent) { try { videoEvent.UnderSampleRate = ChildDouble(parent, "UnderSampleRate"); } catch {} try { videoEvent.MaintainAspectRatio = ChildBoolean(parent, "MaintainAspectRatio"); } catch {} try { videoEvent.ReduceInterlace = ChildBoolean(parent, "ReduceInterlace"); } catch {} try { videoEvent.ResampleMode = ChildVideoResampleMode(parent, "ResampleMode"); } catch {} } Take activeTake = ImportTakes(parent, trackEvent.Takes, trackEvent.MediaType); if (null != activeTake) { trackEvent.ActiveTake = activeTake; } ImportFade(parent, "FadeIn", trackEvent.FadeIn); ImportFade(parent, "FadeOut", trackEvent.FadeOut); if (null != videoEvent) { ImportEnvelopes(parent, videoEvent.Envelopes); ImportEffects(parent, videoEvent.Effects, myVegas.VideoFX); ImportVideoMotion(parent, videoEvent.VideoMotion); } }
void EmitTrackChange(bool state) { var msg = new TrackEvent { Track = Track, State = state }; MessageBroker.Default.Publish(msg); }
private void InitEvent() { gameEvent = EventManager._init.Game; trackEvent = gameEvent.TrackEvent; trackEvent.InitEvents += Init_TrackEvent; playerCarEvent = gameEvent.CarEvent.Player; playerCarEvent.InitEvents += Init_PlayerCarEvent; }
public bool IsTimecodeAfterTrackEvent(TrackEvent trackEvent, Timecode timecode, bool exclusive = false) { if (exclusive) { return(trackEvent.Start < timecode); } return(trackEvent.Start <= timecode); }
public bool IsTimecodeBeforeTrackEvent(TrackEvent trackEvent, Timecode timecode, bool exclusive = false) { if (exclusive) { return((trackEvent.Start + trackEvent.Length) > timecode); } return((trackEvent.Start + trackEvent.Length) >= timecode); }
public bool ContainsEvent(TrackEvent Event) { if (_Events.Contains(Event)) { return(true); } return(false); }
/// <summary> /// Log a usage event. /// </summary> /// <param name="category"></param> /// <param name="action"></param> /// <param name="label"></param> /// <param name="value"></param> public static void LogEvent(string category = null, string action = null, string label = null, int value = 0) { TrackEvent e = new TrackEvent { Category = category, Action = action, Label = label, Value = value }; SendEvent(e); }
void ExportTrackEvent(XmlElement parent, TrackEvent trackEvent) { Type type = trackEvent.GetType(); VideoEvent videoEvent = null; AudioEvent audioEvent = null; if (type.Name == "AudioEvent") { audioEvent = (AudioEvent)trackEvent; } else if (type.Name == "VideoEvent") { videoEvent = (VideoEvent)trackEvent; } XmlElement elt = AddChild(parent, type.Name); ChildString(elt, "Name", trackEvent.Name); ChildInt32(elt, "Index", trackEvent.Index); ChildObject(elt, "MediaType", trackEvent.MediaType); ChildTimecode(elt, "Start", trackEvent.Start); ChildTimecode(elt, "Length", trackEvent.Length); ChildTimecode(elt, "End", trackEvent.End); ChildDouble(elt, "PlaybackRate", trackEvent.PlaybackRate); ChildBoolean(elt, "Mute", trackEvent.Mute); ChildBoolean(elt, "Locked", trackEvent.Locked); ChildBoolean(elt, "Loop", trackEvent.Loop); ChildBoolean(elt, "Selected", trackEvent.Selected); if (null != audioEvent) { ChildBoolean(elt, "Normalize", audioEvent.Normalize); ChildBoolean(elt, "InvertPhase", audioEvent.InvertPhase); ChildObject(elt, "Channels", audioEvent.Channels); } else if (null != videoEvent) { ChildDouble(elt, "UnderSampleRate", videoEvent.UnderSampleRate); ChildBoolean(elt, "MaintainAspectRatio", videoEvent.MaintainAspectRatio); ChildBoolean(elt, "ReduceInterlace", videoEvent.ReduceInterlace); ChildObject(elt, "ResampleMode", videoEvent.ResampleMode); } ExportTakes(elt, trackEvent.Takes); if (null == trackEvent.ActiveTake) { AddChild(elt, "ActiveTake"); } else { ChildString(elt, "ActiveTake", trackEvent.ActiveTake.Name); } ExportFade(elt, "FadeIn", trackEvent.FadeIn); ExportFade(elt, "FadeOut", trackEvent.FadeOut); if (null != videoEvent) { ExportEnvelopes(elt, videoEvent.Envelopes); ExportEffects(elt, videoEvent.Effects, true); ExportVideoMotion(elt, videoEvent.VideoMotion); } }
public EventPropertiesTemplate(TrackEvent Event, Region ParentRegion = null) { FadeIn = new SerializableFade(Event.FadeIn); FadeOut = new SerializableFade(Event.FadeOut); Loop = Event.Loop; PlaybackRate = Event.PlaybackRate; LengthNanos = Event.Length.Nanos; RegionOffsetNanos = ParentRegion != null ? Event.Start.Nanos - ParentRegion.Position.Nanos : 0; }
public void SetTrack(TrackEvent track) { this.track = track; if (playing) { _spotify.PlayURL(this.track.Url); } }
//Trims the start of the track event to a global timecode and sets the duration public void TrimEvent(ref TrackEvent trackEvent, Timecode globalLocation, Timecode duration) { SplitAndKeepRight(ref trackEvent, globalLocation); if (trackEvent == null) { return; } trackEvent.AdjustStartLength(trackEvent.Start, duration, false); }
public async Task <Unit> Handle(Command request, CancellationToken cancellationToken) { var trackEvent = new TrackEvent { Id = request.Id, JobId = request.jobId, JobName = request.jobName, UserId = request.userId, Event = request.eventTracked, Source = request.source, ActionDate = request.actionDate, RemoteIP = request.remoteIP, RequestProperties = request.requestProperties, RemoteResponse = "" }; _context.TrackEvents.Add(trackEvent); //handler logic var success = await _context.SaveChangesAsync(true) > 0; if (success) { var runJob = await _remote.PostRemote(request.remoteIP, request.eventTracked, request.jobName); if (!runJob.Contains("successfully")) { throw new Exception("Failed Running Remote Job"); } else { //return Unit.Value; var response = await _context.TrackEvents.FindAsync(request.Id); if (response == null) { throw new RestException(HttpStatusCode.NotFound, new { TrackEvent = "Not Found" }); } else { response.RemoteResponse = runJob; var responseSuccess = await _context.SaveChangesAsync(true) > 0; if (success) { return(Unit.Value); } throw new Exception("problem updating response"); } } } else { throw new Exception("problem saving changes"); } }
private void SetCurrentMarkerOffset(TrackEvent Event, Timecode Offset) { MetaMarker mmk = Event.FindCurrentMetaMarker(); if (mmk == null) { return; } Event.ActiveTake.Offset = mmk.LocalMarkerOffset - Offset; }
private void EventPropertiesChangeCopy(TrackEvent SourceEvent) { var tpl = new EventPropertiesTemplate(SourceEvent); var fmt = new BinaryFormatter(); var str = new MemoryStream(); fmt.Serialize(str, tpl); byte[] bytes = str.GetBuffer(); Clipboard.SetData(Strings.ClipboardTemplateTag, bytes); }
internal static Marker FindCurrentMarker(this TrackEvent Event) { MetaMarker mmk = Event.FindCurrentMetaMarker(); if (mmk != null) { return(mmk.Marker); } return(null); }
internal static Timecode DistanceToRegion(this Vegas Vegas, TrackEvent Event) { var surroundingRegions = Vegas.Project.Regions.Where(r => r.Position <= Event.Start && r.End >= Event.End).ToList(); if (!surroundingRegions.Any()) return null; Region region = surroundingRegions[0]; return (Event.Start - region.Position); }
public static void Track(TrackEvent ev) { // TODO }
public static void Track(TrackEvent ev, Dictionary<String, String> attributes) { // TODO }
internal static Region FindSurroundingRegion(this Vegas Vegas, TrackEvent Event) { return Vegas.Project.Regions.FirstOrDefault(r => r.ContainsTime(Event.Start, Event.Length)); }
public static void Track(TrackEvent ev, string attribute, Exception e) { // TODO }
public bool ContainsEvent(TrackEvent Event) { if (_Events.Contains(Event)) return true; return false; }
public void SetMetaTake(TrackEvent TrackEvent, int MarkerIndex) { Marker mk = TrackEvent.FindCurrentMarker(); if (mk == null) return; Marker targetMk; try { targetMk = TrackEvent.ActiveTake.Media.Markers[MarkerIndex]; } catch { return; } SetMetaTake(TrackEvent, targetMk); }
public void AddEvent(TrackEvent Event) { _Events.Add(Event); _Events.Sort(); }
public void RemoveEvent(TrackEvent Event) { if (_Events.Contains(Event)) _Events.Remove(Event); }
private void SetCurrentMarkerOffset(TrackEvent Event, Timecode Offset) { MetaMarker mmk = Event.FindCurrentMetaMarker(); if (mmk == null) return; Event.ActiveTake.Offset = mmk.LocalMarkerOffset - Offset; }
public void SetMetaTake(TrackEvent TrackEvent, Marker TargetMarker) { MetaMarker currentMmk = TrackEvent.FindCurrentMetaMarker(); if (currentMmk == null) return; var targetMmk = new MetaMarker(TargetMarker, TrackEvent); TrackEvent.ActiveTake.Offset = targetMmk.GlobalMarkerPosition - currentMmk.GlobalMarkerOffset; }
private static void SendEvent(TrackEvent e) { UdpEvent("event", e); }