/// <summary>
/// There can only be one selected (active) b/w video and audio line, so audio will be set to null
/// Needs proj to find absolute frame position (CurrentClipFrameAbsPos)
/// </summary>
public void SetActiveVideo(VidkaClipVideo active, VidkaProj proj)
{
if (CurrentVideoClip != active ||
CurrentAudioClip != null)
{
stateChanged = true;
originalTimelineSelectionChanged = true;
SetOriginalTimelinePlaybackMode(false);
}
CurrentVideoClip = active;
CurrentAudioClip = null;
CurrentClipFrameAbsPos = (active != null)
? (long?)proj.GetVideoClipAbsFramePositionLeft(active)
: null;
}
public static void RebuildAuxillaryFiles(VidkaProj proj, string projFilename, MetaGeneratorInOtherThread metaGenerator, bool newFilenames)
{
foreach (var clip in proj.ClipsVideo)
{
if (clip is VidkaClipTextSimple)
{
var vclip = (VidkaClipTextSimple)clip;
if (newFilenames)
{
vclip.FileName = GetAuxillaryProjFile(projFilename, MakeUniqueFilename_AuxSimpleText());
}
RebuildAuxillaryFile_SimpleText(vclip, proj, metaGenerator);
}
}
}
public void DrawProjectAudioTimeline(
Graphics g,
int Width,
int Height,
VidkaProj proj,
ProjectDimensions dimdim,
VidkaClipAudio currentAudioClip,
EditorDraggy draggy)
{
// draw video events
long curFrame = 0;
int y1 = dimdim.getY_audio1(Height);
int y2 = dimdim.getY_audio2(Height);
int cliph = y2 - y1;
foreach (var aclip in proj.ClipsAudio)
{
if (dimdim.isEvenOnTheScreen(curFrame, curFrame + aclip.LengthFrameCalc, Width))
{
int x1 = dimdim.convert_Frame2ScreenX(curFrame);
int x2 = dimdim.convert_Frame2ScreenX(curFrame + aclip.LengthFrameCalc);
int clipw = x2 - x1;
// active video clip deserves a special outline
//if (aclip == currentAudioClip)
// g.FillRectangle(brushActive, x1, y1, clipw, clipvh);
//else
// g.FillRectangle(brushWhite, x1, y1, clipw, clipvh);
throw new NotImplementedException("DrawWaveform that takes Audio clip!!!");
//DrawWaveform(g, proj, aclip, x1, y1, clipw, cliph,
// proj.FrameToSec(aclip.FrameStart), proj.FrameToSec(aclip.FrameEnd));
// outline rect
g.DrawRectangle(penDefault, x1, y1, clipw, cliph);
}
curFrame += aclip.LengthFrameCalc;
}
if (draggy.Mode == EditorDraggyMode.AudioTimeline)
{
var draggyX = draggy.MouseX - draggy.MouseXOffset;
var draggyW = dimdim.convert_FrameToAbsX(draggy.FrameLength); // hacky, i know
g.DrawRectangle(penBorderDrag, draggyX, y1, draggyW, cliph);
}
}
public HowTheFuckDidThisHappenException(VidkaProj proj, string message)
: base(message
+ " IMPORTANT: A backup of the project has been saved to "
+ Settings.Default.ProjBackupFile
+ " relative to editor executable or something.")
{
// write to file
XmlSerializer x = new XmlSerializer(typeof(VidkaProj));
var fs = new FileStream(Settings.Default.ProjBackupFile, FileMode.Create);
x.Serialize(fs, proj);
fs.Close();
// write to error log
VidkaErrorLog.Logger.Log(message);
}
/// <param name="secStart">needs to be in seconds to figure out which thumb</param>
/// <param name="len">needs to be in seconds to figure out which thumb</param>
private void DrawClipBitmaps(
Graphics g,
VidkaProj proj,
VidkaFileMapping projMapping,
VidkaClipVideo vclip,
int x1, int y1, int clipw, int clipvh,
double secStart, double len)
{
string thumbsFile = projMapping.AddGetThumbnailFilename(vclip.FileName);
//if (!File.Exists(thumbsFile))
// return;
//Image origThumb = System.Drawing.Image.FromFile(thumbsFile, true);
//var bmpThumb = new Bitmap(origThumb);
var heightForThumbs = Math.Max(clipvh - 2 * THUMB_MARGIN_Y, ThumbnailTest.ThumbH);
var thumbPrefWidth = heightForThumbs * ThumbnailTest.ThumbW / ThumbnailTest.ThumbH;
var howManyThumbs = (clipw - THUMB_MARGIN) / (thumbPrefWidth + THUMB_MARGIN);
if (howManyThumbs == 0)
{
howManyThumbs = 1;
}
var xCenteringOffset = (clipw - howManyThumbs * (thumbPrefWidth + THUMB_MARGIN)) / 2;
for (int i = 0; i < howManyThumbs; i++)
{
//DrawVideoThumbnail(
// g: g,
// bmpAll: bmpThumb,
// timeSec: secStart + (i + 0.5) * len / howManyThumbs,
// xCenter: x1 + xCenteringOffset + i * (thumbPrefWidth + THUMB_MARGIN) + (thumbPrefWidth + THUMB_MARGIN) / 2,
// yCenter: y1 + clipvh / 2,
// preferredWidth: thumbPrefWidth,
// maxWidth: clipw);
var timeSec = secStart + (i + 0.5) * len / howManyThumbs;
var imageIndex = (int)(timeSec / ThumbnailTest.ThumbIntervalSec);
DrawVideoThumbnail(
g: g,
filenameAll: thumbsFile,
index: imageIndex,
xCenter: x1 + xCenteringOffset + i * (thumbPrefWidth + THUMB_MARGIN) + (thumbPrefWidth + THUMB_MARGIN) / 2,
yCenter: y1 + clipvh / 2,
preferredWidth: thumbPrefWidth,
maxWidth: clipw);
}
//bmpThumb.Dispose();
//origThumb.Dispose();
}
public DragAndDropManager(IVideoShitbox editor, VidkaProj proj, VidkaFileMapping fileMapping)
{
this.editor = editor;
Proj = proj;
Mode = DragAndDropManagerMode.None;
_draggies = new List <DragAndDropMediaFile>();
outstandingVideo = new List <VidkaClipVideoAbstract>();
outstandingAudio = new List <VidkaClipAudio>();
metaGenerator = new MetaGeneratorInOtherThread(fileMapping);
//metaGenerator.OneItemFinished += metaGenerator_OneItemFinished;
//metaGenerator.MetaGeneratorDone += metaGenerator_MetaGeneratorDone;
metaGenerator.HereIsSomeTextForConsole += genericListener_AppendToConsole;
metaGenerator.MetaReady += metaGenerator_MetaReady;
metaGenerator.ThumbnailsReady += metaGenerator_ThumbReady;
metaGenerator.WaveformReady += metaGenerator_WaveReady;
metaGenerator.PleaseUnlockThisFile += metaGenerator_PleaseUnlockThisFile;
}
/// <summary>
/// There can only be one selected (active) b/w video and audio line, so audio will be set to null
/// Needs proj to find absolute frame position (CurrentClipFrameAbsPos)
/// </summary>
public void SetActiveVideo(VidkaClipVideoAbstract active, VidkaProj proj)
{
if (CurrentVideoClip != active ||
CurrentAudioClip != null)
{
stateChanged = true;
originalTimelineSelectionChanged = true;
SetOriginalTimelinePlaybackMode(false);
}
CurrentVideoClip = ArrayOfOne_ClipsVideo[0] = active;
CurrentAudioClip = null;
resetCurrentClipUsages();
if (active != null)
{
CurClipAllUsagesVideo = ArrayOfOne_ClipsVideo;
}
UpdateCurrentClipFrameAbsPos(proj);
}
public DragAndDropManager(IVideoEditor editor, VidkaProj proj, VidkaFileMapping fileMapping)
{
this.editor = editor;
Proj = proj;
Mode = DragAndDropManagerMode.None;
_draggies = new List <DragAndDropMediaFile>();
outstandingVideo = new List <VidkaClipVideo>();
outstandingAudio = new List <VidkaClipAudio>();
EXT_video = Settings.Default.FileExtensionsVideo.Split('|');
EXT_audio = Settings.Default.FileExtensionsAudio.Split('|');
metaGenerator = new MetaGeneratorInOtherThread(fileMapping);
//metaGenerator.OneItemFinished += metaGenerator_OneItemFinished;
//metaGenerator.MetaGeneratorDone += metaGenerator_MetaGeneratorDone;
metaGenerator.HereIsSomeTextForConsole += genericListener_AppendToConsole;
metaGenerator.MetaReady += metaGenerator_MetaReady;
metaGenerator.ThumbnailsReady += metaGenerator_ThumbReady;
metaGenerator.WaveformReady += metaGenerator_WaveReady;
}
private void RenderToAvi(string xmlFilename, VidkaProj proj, string fileOutVideo, string mencoderArgs)
{
var fileOutAvs = VidkaIO.GetGeneratedAvsTmpFilename();
VidkaIO.ExportToAvs(proj, fileOutAvs);
Context.iiii("------ export to " + Settings.Default.ExportVideoExtension + "------");
Context.iiii("Exported to " + fileOutAvs);
#if RUN_MENCODER
Context.InvokeOpByName("RebuildProject");
Context.iiii("Exporting to " + fileOutVideo);
var mencoding = new MEncoderSaveVideoFile(fileOutAvs, fileOutVideo, mencoderArgs);
Context.iiii("------ executing: ------");
Context.iiii(mencoding.FullCommand);
Context.iiii("------");
mencoding.RunMEncoder();
Context.iiii("Exported to " + fileOutVideo);
Context.iiii("Done export.");
#endif
}
public void DrawTimeAxis(Graphics g, ProjectDimensions dimdim, int w, int h, VidkaProj proj)
{
// compute how many segments/ticks/etc to draw
var frameStart = dimdim.convert_ScreenX2Frame(0);
var frameEnd = dimdim.convert_ScreenX2Frame(w);
int nSegments = w / Settings.Default.MinnimumTimelineSegmentSizeInPixels;
long framesPerSegment = (frameEnd - frameStart) / nSegments;
int secondsPerSegment = (int)(framesPerSegment / proj.FrameRate);
secondsPerSegment = Utils.GetClosestSnapToSecondsForTimeAxis(secondsPerSegment);
if (secondsPerSegment == 0) // we are zoomed in so much, but still show seconds
{
secondsPerSegment = 1;
}
// now that everything is rounded, how many segments do we really have?
var actualFramesPerSegment = secondsPerSegment * proj.FrameRate;
var actualNSegments = (int)((frameEnd - frameStart) / actualFramesPerSegment);
var startingSecond = (long)Math.Floor(proj.FrameToSec(frameStart));
// compute dimensions...
var y1 = h - dimdim.getY_timeAxisHeight(h);
var y2 = h;
g.DrawLine(penGray, 0, y1, w, y1);
for (var i = 0; i < actualNSegments + 1; i++)
{
var curSecond = startingSecond + i * secondsPerSegment;
var scrX = dimdim.convert_Sec2ScreenX(curSecond);
var ts = TimeSpan.FromSeconds(curSecond);
g.DrawLine(penGray, scrX, y1, scrX, y2);
g.DrawString(ts.ToString_MinuteOrHour(), fontDefault, brushDefault, scrX + 2, y1 + 4);
}
if (secondsPerSegment == 1 && framesPerSegment <= proj.FrameRate)
{
// draw frame ticks as well
for (var i = frameStart; i < frameEnd; i++)
{
var scrX = dimdim.convert_Frame2ScreenX(i);
g.DrawLine(penGray, scrX, y1, scrX, y1 + 3);
}
}
}
private void drawVideoClip(Graphics g,
VidkaClipVideo vclip,
long curFrame, int y1, int cliph, int clipvh,
Brush brushClip,
VidkaProj proj,
VidkaFileMapping projMapping,
ProjectDimensions dimdim)
{
int x1 = dimdim.convert_Frame2ScreenX(curFrame);
int x2 = dimdim.convert_Frame2ScreenX(curFrame + vclip.LengthFrameCalc);
int clipw = x2 - x1;
// active video clip deserves a special outline, fill white otherwise to hide gray background
g.FillRectangle(brushClip, x1, y1, clipw, clipvh);
DrawClipBitmaps(
g: g,
proj: proj,
projMapping: projMapping,
vclip: vclip,
x1: x1,
y1: y1,
clipw: clipw,
clipvh: clipvh,
secStart: proj.FrameToSec(vclip.FrameStart),
len: proj.FrameToSec(vclip.LengthFrameCalc));
DrawWaveform(g, proj, projMapping, vclip, x1, y1 + clipvh, clipw, cliph - clipvh,
proj.FrameToSec(vclip.FrameStart), proj.FrameToSec(vclip.FrameEnd));
if (vclip.IsMuted)
{
g.FillRectangle(brushHazyMute, x1, y1 + clipvh, x2 - x1, cliph - clipvh);
}
// waveform separator
g.DrawLine(penGray, x1, y1 + clipvh, x2, y1 + clipvh);
// outline rect
g.DrawRectangle(penDefault, x1, y1, clipw, cliph);
// still analyzing...
if (vclip.IsNotYetAnalyzed)
{
g.DrawString("Still analyzing...", fontDefault, brushDefault, x1 + 5, y1 + 5);
}
}
private void RunMPlayer(string filenameAvs, VidkaProj proj)
{
Process process = new Process();
if (ExternalPlayer == ExternalPlayerType.Mplayer)
{
process.StartInfo.FileName = OpBaseClass.MplayerExecutable;
process.StartInfo.Arguments = String.Format("\"{0}\" -vo gl -noautosub -geometry {1}x{2} -idle -fixed-vo -loop 1000",
filenameAvs,
proj.Width,
proj.Height);
}
else if (ExternalPlayer == ExternalPlayerType.VirtualDub)
{
process.StartInfo.FileName = OpBaseClass.VirtualDubExecutable;
process.StartInfo.Arguments = String.Format("\"{0}\"", filenameAvs);
}
process.StartInfo.WindowStyle = ProcessWindowStyle.Normal;
//process.StartInfo.CreateNoWindow = true;
runProcessRememberError(process);
}
public void SetParticulars(
VidkaClipVideoAbstract vclip,
MetaGeneratorInOtherThread metaGenerator,
VidkaFileMapping fileMapping,
VidkaProj proj)
{
this.vclip = vclip;
this.metaGenerator = metaGenerator;
this.fileMapping = fileMapping;
this.proj = proj;
// ..... set up the vclip that we will draw
vclipFullToDraw = vclip.MakeCopy_VideoClip();
vclipFullToDraw.FrameStart = 0;
vclipFullToDraw.FrameEnd = vclipFullToDraw.LengthFrameCalc;
// ..... set up UI
chkHasCustomAudio.Checked = vclip.HasCustomAudio;
txtOffset.Text = "" + vclip.CustomAudioOffset;
//shitboxAlignVideoAudioControl.SetParticulars(vclip, fileMapping);
SetFilenameLabel(vclip.CustomAudioFilename);
updateAudioInfo(vclip);
updateDisabilityOfControlBasedOnCheckbox();
}
public void PleaseShowAllUsages(VidkaProj proj)
{
stateChanged = true;
CurClipAllUsagesVideo = proj.ClipsVideo.Where(x => x.FileName == CurrentClip.FileName);
CurClipAllUsagesAudio = proj.ClipsAudio.Where(x => x.FileName == CurrentClip.FileName);
}
public ProjectDimensions(VidkaProj proj)
{
this.proj = proj;
init();
}
public void setProj(VidkaProj proj)
{
this.proj = proj;
}
internal void DrawCurrentClipVideo(
Graphics g,
VidkaClipVideo vclip,
ProjectDimensions dimdim,
VidkaProj proj,
VidkaFileMapping projMapping,
int w, int h,
OutlineClipType type,
bool isOriginalPlaybackMode,
TrimDirection trimDirection,
int trimBracketLength,
long markerFrame,
long selectedClipFrameOffset,
long framesActiveMouseTrim)
{
int yMainTop = dimdim.getY_main1(h);
int xMain1 = dimdim.getScreenX1(vclip);
int xMain2 = xMain1 + dimdim.convert_FrameToAbsX(vclip.LengthFrameCalc); //hacky, I know
int xMainDelta = dimdim.convert_FrameToAbsX(framesActiveMouseTrim); //hacky, I know
int xOrig1 = dimdim.convert_Frame2ScreenX_OriginalTimeline(vclip.FrameStart, vclip.FileLengthFrames, w);
int xOrig2 = dimdim.convert_Frame2ScreenX_OriginalTimeline(vclip.FrameEnd, vclip.FileLengthFrames, w);
int xOrigDelta = dimdim.convert_Frame2ScreenX_OriginalTimeline(framesActiveMouseTrim, vclip.FileLengthFrames, w); // hacky, I know
int y1 = dimdim.getY_original1(h);
int y2 = dimdim.getY_original2(h);
int yaudio = dimdim.getY_original_half(h);
// draw entire original clip (0 .. vclip.FileLength)
g.FillRectangle(brushWhite, 0, y1, w, y2 - y1);
g.FillRectangle(brushActive, xOrig1, y1, xOrig2 - xOrig1, y2 - y1);
DrawClipBitmaps(g, proj, projMapping, vclip, 0, y1, w, yaudio - y1, 0, vclip.FileLengthSec ?? 0);
DrawWaveform(g, proj, projMapping, vclip, 0, yaudio, w, y2 - yaudio, 0, vclip.FileLengthSec ?? 0);
if (vclip.IsMuted)
{
g.FillRectangle(brushHazyMute, xOrig1, yaudio, xOrig2 - xOrig1, y2 - yaudio);
}
g.DrawLine(penGray, 0, yaudio, w, yaudio);
g.DrawRectangle(penDefault, 0, y1, w, y2 - y1);
//draw clip bounds
g.DrawLine((type == OutlineClipType.Hover) ? penHover : penGray, xMain1, yMainTop, xOrig1, y2);
g.DrawLine((type == OutlineClipType.Hover) ? penHover : penGray, xMain2, yMainTop, xOrig2, y2);
g.DrawLine((type == OutlineClipType.Hover) ? penHover : penGray, xOrig1, y1, xOrig1, y2);
g.DrawLine((type == OutlineClipType.Hover) ? penHover : penGray, xOrig2, y1, xOrig2, y2);
if (type == OutlineClipType.Hover)
{
if (trimDirection == TrimDirection.Left)
{
g.DrawLine(penActiveBoundary, xMain1 + xMainDelta, yMainTop, xOrig1 + xOrigDelta, y2);
drawTrimBracket(g, xOrig1, y1, y2, TrimDirection.Left, trimBracketLength, xOrigDelta, dimdim);
}
if (trimDirection == TrimDirection.Right)
{
g.DrawLine(penActiveBoundary, xMain2 + xMainDelta, yMainTop, xOrig2 + xOrigDelta, y2);
drawTrimBracket(g, xOrig2, y1, y2, TrimDirection.Right, trimBracketLength, xOrigDelta, dimdim);
}
}
// draw marker on
var frameOffset = isOriginalPlaybackMode
? markerFrame
: markerFrame - selectedClipFrameOffset + vclip.FrameStart;
int xMarker = dimdim.convert_Frame2ScreenX_OriginalTimeline(frameOffset, vclip.FileLengthFrames, w);
g.DrawLine(penMarker, xMarker, y1, xMarker, y2);
}
public void DrawProjectVideoTimeline(
Graphics g,
int Width,
int Height,
VidkaProj proj,
VidkaFileMapping projMapping,
ProjectDimensions dimdim,
VidkaClipVideo currentVideoClip,
EditorDraggy draggy)
{
// draw video events
long curFrame = 0;
int y1 = dimdim.getY_main1(Height);
int y2 = dimdim.getY_main2(Height);
int yaudio = dimdim.getY_main_half(Height);
int cliph = y2 - y1; // clip height (video and audio)
int clipvh = yaudio - y1; // clip (only video) height (just the video part, no audio!)
int index = 0;
int draggyVideoShoveIndex = dimdim.GetVideoClipDraggyShoveIndex(draggy);
foreach (var vclip in proj.ClipsVideo)
{
if (dimdim.isEvenOnTheScreen(curFrame, curFrame + vclip.LengthFrameCalc, Width))
{
if (draggy.Mode == EditorDraggyMode.VideoTimeline && draggyVideoShoveIndex == index)
{
drawDraggyVideo(g, curFrame, y1, cliph, clipvh, draggy, dimdim);
curFrame += draggy.FrameLength;
}
if (draggy.VideoClip != vclip)
{
var brush = brushWhite;
if (vclip == currentVideoClip && vclip.IsLocked)
{
brush = brushLockedActiveClip;
}
else if (vclip == currentVideoClip)
{
brush = brushActive;
}
else if (vclip.IsLocked)
{
brush = brushLockedClip;
}
drawVideoClip(g, vclip,
curFrame, y1, cliph, clipvh,
brush,
proj, projMapping, dimdim
);
}
}
index++;
if (draggy.VideoClip != vclip)
{
curFrame += vclip.LengthFrameCalc;
}
}
if (draggy.Mode == EditorDraggyMode.VideoTimeline && draggyVideoShoveIndex == index)
{
drawDraggyVideo(g, curFrame, y1, cliph, clipvh, draggy, dimdim);
}
}
public void SetProj(VidkaProj proj)
{
Proj = proj;
}
public DragAndDropMediaFile(VidkaProj proj)
{
this.proj = proj;
}
public static void RebuildAuxillaryFile_SimpleText(VidkaClipTextSimple vclip, VidkaProj Proj, MetaGeneratorInOtherThread metaGenerator)
{
var filename = vclip.FileName;
VidkaIO.MakeSureFolderExistsForFile(filename);
VidkaImaging.RenderSimpleTextVideoClipToFile(vclip, Proj, filename);
metaGenerator.RequestThumbsOnly(filename, true);
}
internal static void ExportToAvs(VidkaProj Proj, string fileOut)
{
var sbFiles = new StringBuilder();
var sbClips = new StringBuilder();
var sbClipsSplice = new StringBuilder();
var sbClipStats = new StringBuilder();
var sbPostOp = new StringBuilder();
var sbAudio = new StringBuilder();
var renderableProj = Proj.GetVideoClipsForRendering();
var renderableClips = renderableProj.Clips;
var lastClip = renderableClips.LastOrDefault();
foreach (var file in renderableProj.Files)
{
if (file.Type == RenderableMediaFileType.DirectShowSource)
{
//sbFiles.Append($"{file.VarName} = DirectShowSource(\"{file.FileName}\", audio=True, fps=proj_frameRate, convertfps=true)");
var audioParam = file.HasAudio ? ", atrack=-1" : "";
sbFiles.Append($"{file.VarName} = FFmpegSource2(\"{file.FileName}\"{audioParam})");
}
else if (file.Type == RenderableMediaFileType.ImageSource)
{
sbFiles.Append($"{file.VarName} = ImageSource(\"{file.FileName}\", start=0, end={renderableProj.MaxLengthOfImageClip}, fps=proj_frameRate)");
}
else if (file.Type == RenderableMediaFileType.AudioSource)
{
sbFiles.Append($"{file.VarName} = DirectShowSource(\"{file.FileName}\")");
}
sbFiles.Append("\n");
}
foreach (var clip in renderableClips)
{
sbPostOp.Clear();
if (clip.HasCustomAudio)
{
sbPostOp.Append(String.Format(".AddCustomAudio({0}, {1}, fstart={2}, fend={3})",
clip.CustomAudioFile.VarName, clip.CustomAudioOffset, clip.FrameStart, clip.FrameEnd - 1));
}
if (clip.IsMuted)
{
sbPostOp.Append(".MuteThisClip()");
}
sbPostOp.Append((clip.PostOp ?? "").Replace("\n", ""));
if (clip.ClipType == VideoClipRenderableType.Video)
{
sbClips.Append(String.Format("{0} = NeutralClip({1}, {2}, {3}){4}\n",
clip.VarName, clip.VideoFile.VarName, clip.FrameStart, clip.FrameEnd - 1, sbPostOp.ToString()));
}
else if (clip.ClipType == VideoClipRenderableType.Image ||
clip.ClipType == VideoClipRenderableType.Text)
{
sbClips.Append(String.Format("{0} = NeutralClipImage({1}, {2}){3}\n",
clip.VarName, clip.VideoFile.VarName, clip.LengthFrameCalc, sbPostOp.ToString()));
}
}
foreach (var clip in renderableClips)
{
var lineEnding = (clip != lastClip) ? ", \\\n" : " ";
sbPostOp.Clear();
if (clip.EasingLeft > 0 || clip.EasingRight > 0)
{
sbPostOp.Append(String.Format(".Trim({0}, {1})",
clip.EasingLeft, clip.LengthFrameCalc - clip.EasingRight));
}
foreach (var mix in clip.MixesAudioFromVideo)
{
sbPostOp.Append(String.Format(".MixAudioFromClip({0}, {1}, {2}, {3})",
mix.ClipVarName, mix.FrameStart, mix.FrameEnd, mix.FrameOffset));
}
sbClipsSplice.Append(String.Format("\t{0}{1}{2}",
clip.VarName, sbPostOp.ToString(), lineEnding));
}
// clip stats
foreach (var clip in renderableProj.StatVideos)
{
sbClipStats.Append(String.Format("collectpixeltypestat({0}, {1})\n",
clip.VideoFile.VarName, clip.LengthFrameCalc));
}
foreach (var clip in renderableProj.AudioClips)
{
sbPostOp.Clear();
sbPostOp.Append((clip.PostOp ?? "").Replace("\n", ""));
sbAudio.Append(String.Format(@"
voiceover=BlankClip(last,{0}) ++BlankClip(last, {1}).AudioDub(DirectShowSource(""{2}"", fps=proj_frameRate, convertfps=true).ResampleAudio(44100)).Trim({3}, {1}){4}
MixAudio(last,voiceover, clip1_factor=1, clip2_factor=1)", clip.FrameOffset, clip.FrameEnd, clip.FileName, clip.FrameStart, sbPostOp.ToString()));
}
var templateFile = GetFileFromThisAppDirectory(TEMPLATE_AVS);
var templateStr = File.ReadAllText(templateFile);
var strVideoClipsSplice = (Proj.ClipsVideo.Count <= 1)
? sbClipsSplice.ToString()
: "UnalignedSplice( \\\n" + sbClipsSplice.ToString() + "\\\n)";
// TODO: inject project properties
var outputStr = templateStr
.Replace("{proj-fps}", "" + Proj.FrameRate)
.Replace("{proj-width}", "" + Proj.Width)
.Replace("{proj-height}", "" + Proj.Height)
.Replace("{video-files}", sbFiles.ToString())
.Replace("{video-clips}", sbClips.ToString() + "\n\n" + strVideoClipsSplice)
.Replace("{collectpixeltypestat-videos}", sbClipStats.ToString())
.Replace("{audio-clips}", sbAudio.ToString())
;
File.WriteAllText(fileOut, outputStr);
}
public static void SetFrameMarker_RightOfAClipJustBefore(this IVidkaOpContext iEditor, VidkaClipAudio clip, VidkaProj proj)
{
long frameMarker = clip.FrameOffset; // start
var rightThreshFrames = proj.SecToFrame(Settings.Default.RightTrimMarkerOffsetSeconds);
// if clip is longer than RightTrimMarkerOffsetSeconds, we can skip to end-RightTrimMarkerOffsetSeconds
if (clip.LengthFrameCalc > rightThreshFrames)
{
frameMarker += clip.LengthFrameCalc - rightThreshFrames;
}
iEditor.SetFrameMarker_ShowFrameInPlayer(frameMarker);
}
public static void SetFrameMarker_RightOfVClipJustBefore(this IVidkaOpContext iEditor, VidkaClipVideoAbstract vclip, VidkaProj proj)
{
long frameMarker = proj.GetVideoClipAbsFramePositionLeft(vclip);
var rightThreshFrames = proj.SecToFrame(Settings.Default.RightTrimMarkerOffsetSeconds);
// if clip is longer than RightTrimMarkerOffsetSeconds, we can skip to end-RightTrimMarkerOffsetSeconds
if (vclip.LengthFrameCalc > rightThreshFrames)
{
frameMarker += vclip.LengthFrameCalc - rightThreshFrames;
}
iEditor.SetFrameMarker_ShowFrameInPlayer(frameMarker);
}
public static void SetFrameMarker_LeftOfVClip(this IVidkaOpContext iEditor, VidkaClipVideoAbstract vclip, VidkaProj proj)
{
long frameMarker = proj.GetVideoClipAbsFramePositionLeft(vclip);
iEditor.SetFrameMarker_ShowFrameInPlayer(frameMarker);
}
public static void SetFrameMarker_LeftOfVClip(this ISomeCommonEditorOperations iEditor, VidkaClipVideo vclip, VidkaProj proj)
{
long frameMarker = proj.GetVideoClipAbsFramePositionLeft(vclip);
iEditor.SetFrameMarker_ShowFrameInPlayer(frameMarker);
}
public MPlayerPlaybackSegment(VidkaProj proj)
{
this.proj = proj;
ExternalPlayer = ExternalPlayerType.Mplayer;
doCrop = false;
}
