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 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);
}
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);
}
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;
}
/// <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);
}
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);
}
