String TimeToString(Timecode time)
{
String[] decimalSeparators = new String[] { CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator };
Int64 nanosPerCentisecond = 100000;
// first round the time to the nearest centisecond
Int64 nanos = time.Nanos;
Double tmp = ((Double)nanos / (Double)nanosPerCentisecond) + 0.5;
nanos = (Int64)tmp * nanosPerCentisecond;
time = Timecode.FromNanos(nanos);
// {"hh:mm:ss", "ddd"}
String[] rgTime = time.ToString(RulerFormat.Time).Split(decimalSeparators, StringSplitOptions.None);
StringBuilder sbRes = new StringBuilder();
sbRes.Append(rgTime[0]);
sbRes.Append(':');
int iCentiseconds = (int)Math.Round(Double.Parse(rgTime[1]) / 10.0);
sbRes.Append(((iCentiseconds / 10) >> 0) % 10);
sbRes.Append(((iCentiseconds / 1) >> 0) % 10);
return(sbRes.ToString());
}
private void EventPitchChange(IEnumerable <TrackEvent> Events, decimal Semitones)
{
using (var undo = new UndoBlock("Pitch " + Semitones.ToString()))
{
var rateChangeFactor = (decimal)Math.Pow((double)MagicRatio, (double)Semitones);
foreach (var ev in Events)
{
decimal newRate = Math.Round((decimal)ev.PlaybackRate * rateChangeFactor, 6);
Timecode newLength = Timecode.FromNanos((long)(ev.Length.Nanos / rateChangeFactor));
// boundary checks / clamps
if (newRate < 0.0m)
{
return;
}
if ((Math.Round(newRate, 3) > 4.0m) || (Math.Round(newRate, 3) < 0.25m))
{
return;
}
ev.AdjustPlaybackRate((double)newRate, true);
ev.Length = newLength;
}
}
}
public void AdjustRegionLength(Timecode LengthAdjustment)
{
if (LengthAdjustment < Timecode.FromNanos(0))
{
LengthAdjustment = Timecode.FromNanos(0);
}
_Region.End = _Region.Position + LengthAdjustment;
}
void RemoveCrossFade(TrackEvent firstEvent, TrackEvent secondEvent)
{
var crossfadeLength = firstEvent.End - secondEvent.Start;
var half = Timecode.FromNanos(crossfadeLength.Nanos / 2);
firstEvent.Length -= half;
firstEvent.FadeOut.Length = Settings.ZeroTime;
secondEvent.Start = firstEvent.End;
secondEvent.Length -= half;
secondEvent.ActiveTake.Offset += half;
secondEvent.FadeIn.Length = Settings.ZeroTime;
}
public static void GetNormalizedTimeSelection(this TransportControl Transport, out Timecode Start, out Timecode End)
{
if (Transport.SelectionLength < Timecode.FromNanos(0))
{
End = Transport.SelectionStart;
Start = End + Transport.SelectionLength;
}
else
{
Start = Transport.SelectionStart;
End = Start = Transport.SelectionLength;
}
}
private void EventPitchChangeSet(IEnumerable <TrackEvent> Events, decimal Semitones)
{
using (var undo = new UndoBlock("Set pitch to " + Semitones.ToString()))
{
foreach (var ev in Events)
{
var rateChangeFactor = Math.Pow((double)MagicRatio, (double)Semitones);
var oldRate = ev.PlaybackRate;
ev.AdjustPlaybackRate(rateChangeFactor, true);
ev.Length = Timecode.FromNanos((long)(ev.Length.Nanos / (ev.PlaybackRate / oldRate)));
}
}
}
Timecode AttributeTimecode(XmlElement elt, String name)
{
// First try to use the Nanos value.
String nanosVal = elt.GetAttribute("Nanos");
if (!String.IsNullOrEmpty(nanosVal))
{
return(Timecode.FromNanos(Int64.Parse(nanosVal, myNumberFormat)));
}
// Fall back to using the string reprsentation.
String val = AttributeString(elt, name);
return(Timecode.FromString(val, myTimecodeFormat));
}
Timecode ChildTimecode(XmlElement parent, String childName)
{
XmlElement childElt = parent[childName];
if (null == childElt)
{
new Timecode();
}
// first try to get the Nanos attribute
String nanoVal = childElt.GetAttribute("Nanos");
if (!String.IsNullOrEmpty(nanoVal))
{
return(Timecode.FromNanos(Int64.Parse(nanoVal, myNumberFormat)));
}
// fall back to using the string representation
String val = childElt.InnerText;
return(Timecode.FromString(val, myTimecodeFormat));
}
private void MarkerCreateMultiCommand_Invoked(object sender, EventArgs e)
{
KeyValuePair <int, Timecode>?data = FormMarkerCreate.GetAmountAndTime();
if (data == null)
{
return;
}
int num = data.Value.Key;
Timecode interval = data.Value.Value;
using (var undo = new UndoBlock("Create multiple markers"))
{
for (int i = 0; i < num; i++)
{
Timecode pos = Timecode.FromNanos(myVegas.Transport.CursorPosition.Nanos + (interval.Nanos * i));
myVegas.Project.Markers.Add(new Marker(pos));
}
}
}
public static List <RegionGroup> GetRegionGroups(this ScriptPortal.Vegas.Vegas Vegas)
{
Timecode selStart = Vegas.Transport.SelectionStart;
Timecode selEnd = Vegas.Transport.SelectionStart + Vegas.Transport.SelectionLength;
if (selStart > selEnd)
{
Ext.SwapTimecode(ref selStart, ref selEnd);
}
bool selection = Vegas.SelectionLength != Timecode.FromNanos(0) && (Vegas.Transport.CursorPosition == selStart || Vegas.Transport.CursorPosition == selEnd);
var rGrps = new List <RegionGroup>();
foreach (var r in Vegas.Project.Regions)
{
if (selection && (r.Position < selStart || r.End > selEnd))
{
continue;
}
var rgr = new RegionGroup(r);
foreach (Track t in Vegas.Project.Tracks)
{
foreach (TrackEvent ev in t.Events)
{
if (ev.Start < r.End && ev.End > r.Position)
{
rgr.AddEvent(ev);
}
}
}
rGrps.Add(rgr);
}
return(rGrps);
}
private void EventPropertiesChangePaste(IEnumerable <TrackEvent> TargetEvents, EventPropertiesFlags Flags)
{
object clipboardData = Clipboard.GetData(Strings.ClipboardTemplateTag);
if (clipboardData == null)
{
return;
}
var bytes = clipboardData as Byte[];
var str = new MemoryStream(bytes);
var fmt = new BinaryFormatter {
Binder = new EventPropertiesTemplateBinder()
};
var tpl = (EventPropertiesTemplate)fmt.Deserialize(str);
using (var undo = new UndoBlock("Paste event properties"))
{
foreach (TrackEvent ev in TargetEvents)
{
if (Flags.IsSet(EventPropertiesFlags.FadeIn))
{
ev.FadeIn.Length = Timecode.FromNanos(tpl.FadeIn.LengthNanos);
}
if (Flags.IsSet(EventPropertiesFlags.FadeOut))
{
ev.FadeOut.Length = Timecode.FromNanos(tpl.FadeOut.LengthNanos);
}
if (Flags.IsSet(EventPropertiesFlags.FadeInCurve))
{
ev.FadeIn.Curve = (CurveType)Enum.Parse(typeof(CurveType), tpl.FadeIn.CurveType);
}
if (Flags.IsSet(EventPropertiesFlags.FadeOutCurve))
{
ev.FadeOut.Curve = (CurveType)Enum.Parse(typeof(CurveType), tpl.FadeOut.CurveType);
}
if (Flags.IsSet(EventPropertiesFlags.Gain))
{
ev.FadeIn.Gain = tpl.FadeIn.Gain;
}
if (Flags.IsSet(EventPropertiesFlags.Loop))
{
ev.Loop = tpl.Loop;
}
if (Flags.IsSet(EventPropertiesFlags.Length))
{
ev.Length = Timecode.FromNanos(tpl.LengthNanos);
}
if (Flags.IsSet(EventPropertiesFlags.PitchAmount))
{
ev.AdjustPlaybackRate(tpl.PlaybackRate, true);
}
if (Flags.IsSet(EventPropertiesFlags.PitchMethod))
{
// Not supported by Vegas API yet
}
// broken, too unintuitive
/*if (Flags.IsSet(EventPropertiesFlags.RegionOffset))
* {
* Region r = myVegas.FindSurroundingRegion(ev);
*
* // workaround to make sure we don't stack events within the same region
* if (r == null || r == LastSurroundingRegion)
* continue;
*
* ev.Start.Nanos = r.Position.Nanos + tpl.RegionOffsetNanos;
* LastSurroundingRegion = r;
* }*/
}
}
}
public static void RunSetup(Vegas Vegas)
{
var nextRegion = Vegas.Project.NextRegion(Vegas.Transport.CursorPosition);
var currentParams = Vegas.Project.GetParamsAt((nextRegion != null) ? nextRegion.Position : Vegas.Project.Length);
var form = new RenderParamsForm(Vegas, currentParams);
if (form.ShowDialog() != DialogResult.OK)
{
return;
}
int offsetCounter = 0;
const long markerSpacing = 10000;
Timecode startPos = Vegas.Transport.CursorPosition;
Timecode currentPos = startPos;
foreach (RenderParameter param in form.UserRenderParams.RenderParams)
{
// skip basedir for now TODO: FIX THIS
if (param.Name == RenderTags.RootDir)
{
continue;
}
// skip params that are the same as previous
var currentParam = currentParams.GetParam(param.Name);
if (param.Value.Equals(currentParam.Value))
{
continue;
}
// find last marker of this type
string paramName = param.Name;
var sameTypeMarkers = Vegas.Project.CommandMarkers.Where(item => item.CommandType.ToString().Equals(paramName, StringComparison.InvariantCultureIgnoreCase));
var sameRegionMarkers = sameTypeMarkers.Where(sibling => !Vegas.Project.RegionsBetween(sibling.Position, currentPos));
CommandMarker updateCandidate = null;
// dooo eeet
foreach (var sibling in sameRegionMarkers)
{
updateCandidate = sibling;
}
if (updateCandidate != null)
{
updateCandidate.CommandParameter = param.Value.ToString();
}
else
{
CommandMarker mk = null;
do
{
try
{
mk = new CommandMarker(currentPos, new MarkerCommandType(param.Name), param.Value.ToString());
}
catch (Exception)
{
currentPos += Timecode.FromNanos(markerSpacing * offsetCounter++);
}
} while (mk == null);
Vegas.Project.CommandMarkers.Add(mk);
currentPos = startPos + Timecode.FromNanos(markerSpacing * offsetCounter++);
}
}
}
/// Spacing manipulation
///
private void EventPosSpaceChange(EventPositionModifyMethod Method)
{
List <TrackEvent> TargetEvents = myVegas.Project.GetSelectedEvents(true);
if (TargetEvents.Count <= 1)
{
TargetEvents = GetEventsByTimeSelection();
if (TargetEvents.Count <= 1)
{
return;
}
}
TrackEvent FirstEvent = TargetEvents[0];
TrackEvent LastEvent = TargetEvents[TargetEvents.Count - 1];
// Auto
if (Method == EventPositionModifyMethod.Auto)
{
int _NumEvents = TargetEvents.Count;
var MediaLength = new Timecode();
MediaLength = TargetEvents.Aggregate(MediaLength, (current, CurrentEvent) => current + CurrentEvent.Length);
Timecode TotalTime = LastEvent.End - FirstEvent.Start;
Timecode Space = TotalTime - MediaLength;
Timecode MediumInterval = Timecode.FromNanos((Space.Nanos / (_NumEvents - 1)));
using (var undo = new UndoBlock("Spacing: auto"))
{
TrackEvent prevEvent = null;
for (int eventCounter = 1; eventCounter < TargetEvents.Count; eventCounter++)
{
TrackEvent curEvent = TargetEvents[eventCounter];
if (curEvent != null)
{
if (prevEvent != null)
{
curEvent.Start = prevEvent.End + MediumInterval;
}
}
prevEvent = curEvent;
}
}
return;
}
// User
if (Method == EventPositionModifyMethod.User)
{
Timecode userInterval = FormTimeEntry.GetUserTime();
if (userInterval == null)
{
return;
}
using (var undo = new UndoBlock("Spacing: user"))
{
TrackEvent prevEvent = null;
for (int eventCounter = 0; eventCounter < TargetEvents.Count; eventCounter++)
{
TrackEvent curEvent = TargetEvents[eventCounter];
if (curEvent != null)
{
if (prevEvent != null)
{
curEvent.Start = prevEvent.End + userInterval;
}
}
prevEvent = curEvent;
}
}
}
}
/// Position manipulation
///
private void EventPosInterChange(EventPositionModifyMethod Method, Timecode Interval)
{
List <TrackEvent> selectedEvents = myVegas.Project.GetSelectedEvents(true);
if (selectedEvents.Count <= 1)
{
selectedEvents = GetEventsByTimeSelection();
if (selectedEvents.Count <= 1)
{
return;
}
}
TrackEvent FirstEvent = selectedEvents[0];
TrackEvent LastEvent = selectedEvents[selectedEvents.Count - 1];
if ((Control.ModifierKeys & Keys.Shift) == Keys.Shift)
{
Interval = (Timecode.FromNanos(Interval.Nanos * 10));
}
// Adjust
if ((Method == EventPositionModifyMethod.Adjust))
{
using (var undo = new UndoBlock("Position: adjust"))
{
for (int EventCounter = 1; EventCounter < selectedEvents.Count; EventCounter++)
{
TrackEvent CurEvent = selectedEvents[EventCounter];
if (CurEvent != null)
{
CurEvent.Start = CurEvent.Start + Timecode.FromNanos(Interval.Nanos * EventCounter);
}
}
}
return;
}
// Auto
if (Method == EventPositionModifyMethod.Auto)
{
// get some stats.
Timecode MediumInterval =
Timecode.FromNanos((LastEvent.Start.Nanos - FirstEvent.Start.Nanos) / (selectedEvents.Count - 1));
using (var undo = new UndoBlock("Position: auto"))
{
for (int EventCounter = 1; EventCounter < selectedEvents.Count - 1; EventCounter++)
{
TrackEvent CurEvent = selectedEvents[EventCounter];
if (CurEvent != null)
{
CurEvent.Start = FirstEvent.Start + Timecode.FromNanos(MediumInterval.Nanos * EventCounter);
}
}
}
return;
}
// User
if (Method == EventPositionModifyMethod.User)
{
Timecode UserInterval = FormTimeEntry.GetUserTime();
if (UserInterval == null)
{
return;
}
using (var undo = new UndoBlock("Position: adjust"))
{
for (int EventCounter = 1; EventCounter < selectedEvents.Count; EventCounter++)
{
TrackEvent CurEvent = selectedEvents[EventCounter];
if (CurEvent != null)
{
CurEvent.Start = FirstEvent.Start + Timecode.FromNanos(UserInterval.Nanos * EventCounter);
}
}
}
}
}
