public void FromVegas(Vegas vegas)
        {
            string         rendererName = Script.Args.ValueOf("renderer");
            string         templateName = Script.Args.ValueOf("template");
            Renderer       renderer     = vegas.Renderers.FindByName(rendererName);
            RenderTemplate template     = null;

            if (renderer != null)
            {
                template = renderer.Templates.FindByName(templateName);
            }
            if (template == null)
            {
                vegas.ShowError("Render template not found.");
                return;
            }
            string       path   = vegas.Project.FilePath;
            string       saveas = Path.GetDirectoryName(path) + "\\" + Path.GetFileNameWithoutExtension(path) + ".rendered.mp4";
            RenderStatus status = vegas.Render(saveas, template);

            if (status == RenderStatus.Complete || status == RenderStatus.Canceled || status == RenderStatus.Quit)
            {
                vegas.Exit();
            }
            else
            {
                vegas.ShowError("Render incomplete. Please try again.");
                return;
            }
        }
예제 #2
0
		void FireLivePreviewEndedEvent (RenderStatus status, Exception ex)
		{
			if (Ended != null) {
				var args = new LivePreviewEndedEventArgs (status, ex);
				Ended (this, args);
			}			
		}
예제 #3
0
 public RunningRender(string renderId, string jobId, RenderStatus renderStatus, List <Uri> needMoreResources, bool needMoreDom)
 {
     RenderId          = renderId;
     JobId             = jobId;
     RenderStatus      = renderStatus;
     NeedMoreResources = needMoreResources;
     NeedMoreDom       = needMoreDom;
 }
예제 #4
0
        private void SampleRenderingStatus_(Dictionary <RunningRender, RenderRequest> runningRenders, List <string> ids, List <RenderStatusResults> renderStatusResultsList)
        {
            logger_.Verbose("enter - renderStatusResultsList size: {0}", renderStatusResultsList.Count);

            for (int i = renderStatusResultsList.Count - 1; i >= 0; i--)
            {
                RenderStatusResults renderStatusResults = renderStatusResultsList[i];
                if (renderStatusResults == null)
                {
                    continue;
                }

                RenderStatus renderStatus     = renderStatusResults.Status;
                bool         isRenderedStatus = renderStatus == RenderStatus.Rendered;
                bool         isErrorStatus    = renderStatus == RenderStatus.Error;
                logger_.Verbose("renderStatusResults - {0}", renderStatusResults);
                if (isRenderedStatus || isErrorStatus)
                {
                    string removedId = ids[i];
                    ids.RemoveAt(i);

                    foreach (KeyValuePair <RunningRender, RenderRequest> kvp in runningRenders)
                    {
                        RunningRender renderedRender = kvp.Key;
                        RenderRequest renderRequest  = kvp.Value;
                        if (renderedRender.RenderId.Equals(removedId, StringComparison.OrdinalIgnoreCase))
                        {
                            VisualGridTask task = runningRenders[renderedRender].Task;

                            for (int k = openTasks_.Count - 1; k >= 0; k--)
                            {
                                VisualGridTask openTask = openTasks_[k];
                                if (openTask.RunningTest == task.RunningTest)
                                {
                                    if (isRenderedStatus)
                                    {
                                        logger_.Verbose("setting openTask {0} render result: {1} to url {2}", openTask, renderStatusResults, result_.Url);
                                        openTask.SetRenderResult(renderStatusResults);
                                    }
                                    else
                                    {
                                        logger_.Verbose("setting openTask {0} render error: {1} to url {2}", openTask, removedId, result_.Url);
                                        openTask.SetRenderError(removedId, renderStatusResults.Error, renderRequest);
                                    }
                                    openTasks_.RemoveAt(k);
                                }
                            }

                            logger_.Verbose("setting task {0} render result: {1} to url {2}", task, renderStatusResults, result_.Url);
                            task.SetRenderResult(renderStatusResults);
                            break;
                        }
                    }
                }
            }
            logger_.Verbose("exit");
        }
예제 #5
0
        public static void PlayRender()
        {
            bool needToBegin = Play == RenderStatus.Stop;

            Play = RenderStatus.Play;

            if (needToBegin)
            {
                BeginThreadedRendering();
            }
        }
        public void FromVegas(Vegas vegas)
        {
            string         rendererName = Script.Args.ValueOf("renderer");
            string         templateName = Script.Args.ValueOf("template");
            string         saveas       = Script.Args.ValueOf("saveas", true);
            Renderer       renderer     = vegas.Renderers.FindByName(rendererName);
            RenderTemplate template     = null;

            if (renderer != null)
            {
                template = renderer.Templates.FindByName(templateName);
            }
            if (template == null)
            {
                vegas.ShowError("Render template not found.");
                return;
            }
            if (string.IsNullOrWhiteSpace(saveas))
            {
                SaveFileDialog saveFileDialog = new SaveFileDialog
                {
                    Filter           = ".mp4 file (*.mp4)|*.mp4",
                    Title            = "Select render location",
                    InitialDirectory = vegas.Project.FilePath,
                    CheckPathExists  = true,
                    AddExtension     = true
                };

                if (saveFileDialog.ShowDialog() == DialogResult.OK)
                {
                    saveas = Path.GetFullPath(saveFileDialog.FileName);
                }
            }
            if (string.IsNullOrWhiteSpace(saveas))
            {
                vegas.ShowError("No valid save path exists.");
                return;
            }

            RenderStatus status = vegas.Render(saveas, template);

            if (status == RenderStatus.Complete || status == RenderStatus.Canceled || status == RenderStatus.Quit)
            {
                vegas.Exit();
            }
            else
            {
                vegas.ShowError("Render incomplete. Please try again.");
                return;
            }
        }
예제 #7
0
 private RenderStatus CalcWorstStatus_(List <RunningRender> runningRenders, RenderStatus worstStatus)
 {
     foreach (RunningRender runningRender in runningRenders)
     {
         RenderStatus renderStatus = runningRender.RenderStatus;
         if (renderStatus == RenderStatus.NeedMoreResources && (worstStatus == RenderStatus.Rendered || worstStatus == RenderStatus.Rendering))
         {
             worstStatus = RenderStatus.NeedMoreResources;
         }
         else if (renderStatus == RenderStatus.Error)
         {
             worstStatus = RenderStatus.Error;
             break;
         }
     }
     return(worstStatus);
 }
예제 #8
0
        public void SetRenderStatus(RenderStatus Status)
        {
            this.Invoke(new Action(() =>
            {
                switch (Status)
                {
                case RenderStatus.Ready: lbl_RenderStatus.Text = "准备就绪"; break;

                case RenderStatus.Buffing: lbl_RenderStatus.Text = "正在缓冲"; break;

                case RenderStatus.Playing: lbl_RenderStatus.Text = "正在播放"; break;

                case RenderStatus.Paused: lbl_RenderStatus.Text = "播放暂停"; break;

                case RenderStatus.Stop: lbl_RenderStatus.Text = "正在停止"; break;
                }
            }));
        }
예제 #9
0
        //Creates a temporary WAV file, exporting all audio in the span of the VideoEvent
        public string CreateVideoEventWAV(VideoEvent videoEvent)
        {
            string currentMediaPath           = videoEvent.ActiveTake.MediaPath;
            string currentMediaPathWithoutExt = Path.ChangeExtension(currentMediaPath, null);

            Timecode eventStart  = videoEvent.Start;
            Timecode eventLength = videoEvent.Length;

            string waveOutPath = currentMediaPathWithoutExt + WAV_TEMP_SUFFIX + WAV_EXT;

            Renderer renderer = util.FindRenderer(WAV_RENDERER_NAME);

            if (renderer == null)
            {
                util.ShowError("Renderer \"" + WAV_RENDERER_NAME + "\" not found");
                return(null);
            }

            RenderTemplate renderTemplate = util.FindRenderTemplate(renderer, WAV_RENDER_TEMPLATE_NAME);

            if (renderTemplate == null)
            {
                util.ShowError("RenderTemplate \"" + WAV_RENDER_TEMPLATE_NAME + "\" not found");
                return(null);
            }

            RenderArgs renderArgs = new RenderArgs();

            renderArgs.OutputFile     = waveOutPath;
            renderArgs.RenderTemplate = renderTemplate;
            renderArgs.Start          = eventStart;
            renderArgs.Length         = eventLength;

            RenderStatus renderStatus = util.DoRender(renderArgs);

            if (renderStatus == RenderStatus.Complete)
            {
                return(waveOutPath);
            }

            return(null);
        }
        public bool RenderFile(FileInfo fiVeg, FileInfo fiRendered, RenderTemplate renderTemplate, RenderStatusManager rsm, object dr)
        {
            DateTime renderStart = DateTime.Now;
            DateTime renderEnd;
            TimeSpan renderTime;

            rsm.Dialog.Hide(); // Temporarily hide because during load the UX kills it.
            rsm.UpdateField(dr, RenderStatusManager.Fields.Names.RenderStart, renderStart);
            if (myVegas.Project != null)
            {
                // No close method so create a clean new project without the ability to prompt for save of existing
                // and then open after that.
                myVegas.NewProject(false, false);
            }
            myVegas.UpdateUI();
            rsm.UpdateField(dr, RenderStatusManager.Fields.Names.RenderStatus, "Loading");
            myVegas.OpenFile(fiVeg.FullName);
            myVegas.UpdateUI();
            myVegas.WaitForIdle();
            rsm.Dialog.Show();

            // Render
            RenderArgs ra = new RenderArgs();

            ra.OutputFile     = fiRendered.FullName;
            ra.RenderTemplate = renderTemplate;
            Timecode projectLength = GetProjectLength();

            rsm.UpdateField(dr, RenderStatusManager.Fields.Names.ProjectLength, projectLength);
            ra.Length     = projectLength;
            ra.StartNanos = 0;

            rsm.UpdateField(dr, RenderStatusManager.Fields.Names.RenderStatus, "Rendering");
            RenderStatus status = myVegas.Render(ra);

            renderEnd  = DateTime.Now;
            renderTime = renderEnd - renderStart;
            rsm.UpdateField(dr, RenderStatusManager.Fields.Names.RenderEnd, renderEnd);
            rsm.UpdateField(dr, RenderStatusManager.Fields.Names.RenderTime, renderTime);
            rsm.UpdateField(dr, RenderStatusManager.Fields.Names.RenderStatus, status.ToString());
            return(status == RenderStatus.Complete);
        }
예제 #11
0
        public RenderStatus DoRender(RenderArgs args)
        {
            RenderStatus status = vegas.Render(args);

            switch (status)
            {
            case RenderStatus.Complete:
            case RenderStatus.Canceled:
                break;

            case RenderStatus.Failed:
            default:
                ShowError("Render failed:\n"
                          + "\n    File name: "
                          + args.OutputFile
                          + "\n    Template: "
                          + args.RenderTemplate.Name);
                break;
            }
            return(status);
        }
예제 #12
0
    RenderStatus DoRender(RenderArgs args)
    {
        RenderStatus status = myVegas.Render(args);

        switch (status)
        {
        case RenderStatus.Complete:
        case RenderStatus.Canceled:
            break;

        case RenderStatus.Failed:
        default:
            StringBuilder msg = new StringBuilder("Render failed:\n");
            msg.Append("\n    file name: ");
            msg.Append(args.OutputFile);
            msg.Append("\n    Template: ");
            msg.Append(args.RenderTemplate.Name);
            throw new ApplicationException(msg.ToString());
        }
        return(status);
    }
예제 #13
0
        public bool renderProject(
            Vegas myVegas,
            string projectFilePath,
            string rendererName,
            string templateName,
            string outputFilePath
            )
        {
            if (myVegas.OpenProject(projectFilePath))
            {
                RenderArgs renderArgs = new RenderArgs(myVegas.Project);
                renderArgs.RenderTemplate = findTemplate(rendererName, templateName, myVegas.Renderers);
                renderArgs.OutputFile     = outputFilePath;
                RenderStatus renderStatus = myVegas.Render(renderArgs);
                if (renderStatus == RenderStatus.Complete)
                {
                    return(true);
                }
            }

            return(false);
        }
예제 #14
0
    // perform the render.  The Render method returns a member of the
    // RenderStatus enumeration.  If it is anything other than OK,
    // exit the loops.  This will throw an error message string if the
    // render does not complete successfully.
    RenderStatus DoRender(String filePath, RenderItem renderItem, Timecode start, Timecode length)
    {
        ValidateFilePath(filePath);

        // make sure the file does not already exist
        if (!OverwriteExistingFiles && File.Exists(filePath))
        {
            throw new ApplicationException("File already exists: " + filePath);
        }

        // perform the render.  The Render method returns
        // a member of the RenderStatus enumeration.  If
        // it is anything other than OK, exit the loops.
        RenderStatus status = myVegas.Render(filePath, renderItem.Template, start, length);

        switch (status)
        {
        case RenderStatus.Complete:
        case RenderStatus.Canceled:
            break;

        case RenderStatus.Failed:
        default:
            StringBuilder msg = new StringBuilder("Render failed:\n");
            msg.Append("\n    file name: ");
            msg.Append(filePath);
            msg.Append("\n    Renderer: ");
            msg.Append(renderItem.Renderer.FileTypeName);
            msg.Append("\n    Template: ");
            msg.Append(renderItem.Template.Name);
            msg.Append("\n    Start Time: ");
            msg.Append(start.ToString());
            msg.Append("\n    Length: ");
            msg.Append(length.ToString());
            throw new ApplicationException(msg.ToString());
        }
        return(status);
    }
예제 #15
0
    /**
     * Now Render the project
     * */
    public void RenderProject()
    {
        String totalLength = myVegas.Project.Length.ToString();

        dbg("\n projectpath:");
        dbg(projectPath);
        dbg("\n dir:");
        dbg(projectPath);
        dbg("\n length:");
        dbg(totalLength);
        dbg("\n Template description");
        dbg(this.renderTemplate.Description);
        dbg("\n output filename:");
        dbg(this.outputFilename);

        RenderStatus status = myVegas.Project.Render(projectPath + outputFilename, renderTemplate);

        switch (status)
        {
        case RenderStatus.Complete:
            MessageBox.Show("Incredible, we did it...");
            break;

        case RenderStatus.Canceled:
            MessageBox.Show("cancel");
            break;

        case RenderStatus.Failed:
        default:
            StringBuilder msg = new StringBuilder("Render failed:\n");
            msg.Append("\n    file name: ");
            msg.Append(outputFilename);
            msg.Append("\n    Template: ");
            msg.Append(renderTemplate.Name);
            throw new ApplicationException(msg.ToString());
        }
    }
예제 #16
0
 public LivePreviewEndedEventArgs(RenderStatus status, Exception?exception)
 {
     this.Status    = status;
     this.Exception = exception;
 }
예제 #17
0
파일: UIcheck.cs 프로젝트: ssusH/MouldShow
 // Use this for initialization
 void Start()
 {
     RS = Camera.main.GetComponent <RenderStatus>();
 }
예제 #18
0
        public static bool Send_Msg_To_Readies_Q(RenderStatus status, String item_id, DateTime beforeProcessingTime)
        {
            try
            {

                Dictionary<string, object> dict = new Dictionary<string, object>();

                DateTime current = DateTime.Now;
                TimeSpan duration = current - beforeProcessingTime;

                dict["item_id"] = item_id;
                //dict["url"] = @"http://" + Utils.my_ip + @"/testim/yofi_" + item_id + ".jpg";
                dict["url"] = @"http://s3.amazonaws.com/" + S3.bucketName + @"/" + item_id + ".jpg";
                dict["duration"] = Math.Round(duration.TotalSeconds, 3);
                dict["status"] = status.ToString();

                JavaScriptSerializer serializer = new JavaScriptSerializer(); //creating serializer instance of JavaScriptSerializer class
                string jsonString = serializer.Serialize((object)dict);

                SendMessageRequest sendMessageRequest = new SendMessageRequest();
                sendMessageRequest.QueueUrl = ready_Q_url; //URL from initial queue creation
                sendMessageRequest.MessageBody = Utils.EncodeTo64(jsonString);

                Console.WriteLine("Before sending ready msg(" + sendMessageRequest.MessageBody + ").");
                sqs.SendMessage(sendMessageRequest);
                Console.WriteLine("After sending ready msg(" + sendMessageRequest.MessageBody + ").");
            }
            catch (AmazonSQSException ex)
            {
                Console.WriteLine("Caught Exception: " + ex.Message);
                Console.WriteLine("Response Status Code: " + ex.StatusCode);
                Console.WriteLine("Error Code: " + ex.ErrorCode);
                Console.WriteLine("Error Type: " + ex.ErrorType);
                Console.WriteLine("Request ID: " + ex.RequestId);
                Console.WriteLine("XML: " + ex.XML);
                return false;
            }
            return true;
        }
예제 #19
0
    void DoBatchRender(ArrayList selectedTemplates, String basePath, RenderMode renderMode)
    {
        String outputDirectory = Path.GetDirectoryName(basePath);
        String baseFileName    = Path.GetFileName(basePath);

        // make sure templates are selected
        if ((null == selectedTemplates) || (0 == selectedTemplates.Count))
        {
            throw new ApplicationException("No render templates selected.");
        }

        // make sure the output directory exists
        if (!Directory.Exists(outputDirectory))
        {
            throw new ApplicationException("The output directory does not exist.");
        }

        RenderStatus status = RenderStatus.Canceled;

        // enumerate through each selected render template
        foreach (RenderItem renderItem in selectedTemplates)
        {
            // construct the file name (most of it)
            String filename = Path.Combine(outputDirectory,
                                           FixFileName(baseFileName) +
                                           FixFileName(renderItem.Renderer.FileTypeName) +
                                           "_" +
                                           FixFileName(renderItem.Template.Name));

            if (RenderMode.Regions == renderMode)
            {
                int regionIndex = 0;
                foreach (Sony.Vegas.Region region in myVegas.Project.Regions)
                {
                    String regionFilename = String.Format("{0}[{1}]{2}",
                                                          filename,
                                                          regionIndex.ToString(),
                                                          renderItem.Extension);
                    // Render the region
                    status = DoRender(regionFilename, renderItem, region.Position, region.Length);
                    if (RenderStatus.Canceled == status)
                    {
                        break;
                    }
                    regionIndex++;
                }
            }
            else
            {
                filename += renderItem.Extension;
                Timecode renderStart, renderLength;
                if (renderMode == RenderMode.Selection)
                {
                    renderStart  = myVegas.SelectionStart;
                    renderLength = myVegas.SelectionLength;
                }
                else
                {
                    renderStart  = new Timecode();
                    renderLength = myVegas.Project.Length;
                }
                status = DoRender(filename, renderItem, renderStart, renderLength);
            }
            if (RenderStatus.Canceled == status)
            {
                break;
            }
        }
    }
예제 #20
0
        /// <summary>
        /// Machine data synchronization mechanism.
        /// </summary>
        private void Machine_Update()
        {
            do
            {
                try
                {
                    lock (this.MachineDisplay)
                    {
                        if (this.Machine_TempData != null)
                        {
                            // clear old data ..
                            this.Machine_TempData.Clear();
                        }

                        // change lock flag ..
                        IsLock = true;

                        // reload data ..
                        this.Machine_TempData = this.GenerateMachineData("MachineCache");

                        // add, update items ..
                        foreach (DataRow row in this.Machine_TempData.Rows)
                        {
                            // mapping refresh display columns ..
                            #region Mapping Machine Data Display
                            if (!this.MachineDisplay.Rows.Contains(row["Machine_Id"]))
                            {
                                DataRow drow = this.MachineDisplay.NewRow();

                                drow["Machine_Id"]       = row["Machine_Id"];
                                drow["HostName"]         = row["HostName"];
                                drow["Ip"]               = row["Ip"];
                                drow["IsEnable"]         = row["IsEnable"];
                                drow["Last_Online_Time"] = row["Last_Online_Time"];
                                drow["Machine_Status"]   = row["Machine_Status"];
                                drow["Machine_Priority"] = row["Machine_Priority"];
                                drow["TCore"]            = 0;
                                drow["UCore"]            = 0;
                                drow["Note"]             = row["Note"];

                                // add to machine data displayer collection ..
                                this.MachineDisplay.Rows.Add(drow);
                            }
                            else
                            {
                                if (RenderStatus != null)
                                {
                                    DataRow[]
                                    rows = this.MachineDisplay.Select(string.Format("Machine_Id = '{0}'", row["Machine_Id"])),
                                    renders = RenderStatus.Select(string.Format("MachineId = '{0}'", row["Machine_Id"]));

                                    if (rows.Length > 0 && renders.Length > 0)
                                    {
                                        // update row data ..
                                        rows[0]["HostName"]         = row["HostName"];
                                        rows[0]["Ip"]               = row["Ip"];
                                        rows[0]["IsEnable"]         = row["IsEnable"];
                                        rows[0]["Last_Online_Time"] = row["Last_Online_Time"];

                                        if (Convert.ToUInt16(renders[0]["ConnectFail"]) >= 5)
                                        {
                                            rows[0]["Machine_Status"] = MachineStatusFlag.OFFLINE;
                                        }
                                        else
                                        {
                                            rows[0]["Machine_Status"] = row["Machine_Status"];
                                        }

                                        rows[0]["Machine_Priority"] = row["Machine_Priority"];
                                        rows[0]["TCore"]            = renders[0]["TCore"];
                                        rows[0]["UCore"]            = renders[0]["UCore"];
                                        rows[0]["Note"]             = row["Note"];
                                    }
                                }
                                else
                                {
                                    DataRow[]
                                    rows = this.MachineDisplay.Select(string.Format("Machine_Id = '{0}'", row["Machine_Id"]));

                                    if (rows.Length > 0)
                                    {
                                        // update row data ..
                                        rows[0]["HostName"]         = row["HostName"];
                                        rows[0]["Ip"]               = row["Ip"];
                                        rows[0]["IsEnable"]         = row["IsEnable"];
                                        rows[0]["Last_Online_Time"] = row["Last_Online_Time"];
                                        rows[0]["Machine_Status"]   = row["Machine_Status"];
                                        rows[0]["Machine_Priority"] = row["Machine_Priority"];
                                        rows[0]["TCore"]            = 0;
                                        rows[0]["UCore"]            = 0;
                                        rows[0]["Note"]             = row["Note"];
                                    }
                                }
                            }
                            #endregion
                        }

                        // delete items ..
                        foreach (DataRow row in this.MachineDisplay.Rows)
                        {
                            if (this.Machine_TempData.Rows.Find(row["Machine_Id"]) == null)
                            {
                                row.Delete();
                            }
                        }

                        // commit data changes ..
                        this.MachineDisplay.AcceptChanges();

                        // change lock flag ..
                        IsLock = false;

                        #region Process Render Machine Status For Client
                        if (MachineStatus == null)
                        {
                            // create machine table schema ..
                            MachineStatus = this.MachineDisplay.Clone();
                        }

                        // clear all row(s) ..
                        MachineStatus.Rows.Clear();

                        // declare filiter condition ..
                        string expression = string.Format("Machine_Status = '{0}'", MachineStatusFlag.RENDER);

                        // copy selected row(s) to machine status property ..
                        this.MachineDisplay.Select(expression).CopyToDataTable(MachineStatus, LoadOption.PreserveChanges);
                        #endregion

                        // release thread object locked ..
                        this.runEvents[1].Set();
                    }
                }
                catch (Exception ex)
                {
                    string ExceptionMsg = ex.Message + ex.StackTrace;

                    // write to log file ..
                    this.EnvLog.Writer(AssemblyInfoClass.ProductInfo, Log.Level.Error, ExceptionMsg, true);
                }
                Thread.Sleep(200);
            } while (!requestStop && updateEvents[1].WaitOne());
        }
예제 #21
0
 /// <summary>
 /// Creates a new, empty render result
 /// </summary>
 public RenderResult()
 {
     RenderArea = Rectangle.Empty;
     Status     = RenderStatus.None;
 }
예제 #22
0
        public async Task <RenderStatusResults> CallAsync()
        {
            logger_.Verbose("enter");

            List <RunningRender> runningRenders = null;

            isTaskStarted_ = true;

            RenderRequest[] requests = new RenderRequest[0];

            try
            {
                logger_.Verbose("step 1");

                AddRenderingTaskToOpenTasks_();

                bool isSecondRequestAlreadyHappened = false;

                //Parse to Map
                logger_.Verbose("step 2");
                //Build RenderRequests
                requests = PrepareDataForRG_(result_);

                logger_.Verbose("step 3");
                bool      stillRunning          = true;
                bool      isForcePutAlreadyDone = false;
                Stopwatch timeoutTimer          = Stopwatch.StartNew();
                do
                {
                    try
                    {
                        runningRenders = await connector_.RenderAsync(requests);
                    }
                    catch (Exception e)
                    {
                        var    settings = JsonUtils.CreateSerializerSettings();
                        string j        = JsonConvert.SerializeObject(requests, settings);

                        string responseBodyStr = string.Empty;
                        if (e is WebException we && we.Response != null)
                        {
                            Stream stream            = we.Response.GetResponseStream();
                            byte[] responseBodyBytes = CommonUtils.ReadToEnd(stream);
                            responseBodyStr = Encoding.UTF8.GetString(responseBodyBytes);
                        }

                        logger_.Verbose("/render throws exception. sleeping for 1.5s");
                        Thread.Sleep(1500);

                        if (responseBodyStr.Contains("Second request, yet still some resources were not PUT in renderId"))
                        {
                            if (isSecondRequestAlreadyHappened)
                            {
                                logger_.Verbose("Second request already happened");
                            }
                            isSecondRequestAlreadyHappened = true;
                        }
                        logger_.Verbose("Error (1): " + e);
                        logger_.Verbose("Error Response Body: " + responseBodyStr);
                    }
                    logger_.Verbose("step 4.1");
                    if (runningRenders == null)
                    {
                        logger_.Verbose("ERROR - runningRenders is null.");
                        SetRenderErrorToTasks_(requests);
                        continue;
                    }

                    for (int i = 0; i < requests.Length; i++)
                    {
                        RenderRequest request = requests[i];
                        request.RenderId = runningRenders[i].RenderId;
                    }
                    logger_.Verbose("step 4.2");

                    RunningRender runningRender = runningRenders[0];
                    RenderStatus  worstStatus   = runningRender.RenderStatus;

                    worstStatus = CalcWorstStatus_(runningRenders, worstStatus);

                    bool isNeedMoreDom = runningRender.NeedMoreDom;

                    if (isForcePutNeeded_ && !isForcePutAlreadyDone)
                    {
                        ForcePutAllResources_(requests[0].Resources, runningRender);
                        isForcePutAlreadyDone = true;
                    }

                    logger_.Verbose("step 4.3");
                    stillRunning = (worstStatus == RenderStatus.NeedMoreResources || isNeedMoreDom) && (timeoutTimer.Elapsed.TotalSeconds < FETCH_TIMEOUT_SECONDS);
                    if (stillRunning)
                    {
                        SendMissingResources_(runningRenders, requests[0].Dom, requests[0].Resources, isNeedMoreDom);
                    }

                    logger_.Verbose("step 4.4");
                } while (stillRunning);
            }
            catch (Exception e)
            {
                logger_.Log("Error: " + e);
                SetRenderErrorToTasks_(requests);
            }

            Dictionary <RunningRender, RenderRequest> mapping = MapRequestToRunningRender_(runningRenders, requests);

            logger_.Verbose("step 5");
            try
            {
                PollRenderingStatus_(mapping);
            }
            catch (Exception e)
            {
                isTaskInException = true; // FOR DEBUGGING
                logger_.Log("Error (2): " + e);
                foreach (VisualGridTask visualGridTask in taskList_)
                {
                    visualGridTask.SetExceptionAndAbort(e);
                }
            }

            IsTaskComplete = true;
            logger_.Verbose("exit");
            return(null);
        }
예제 #23
0
 public static void StopRender()
 {
     Play = RenderStatus.Stop;
 }
예제 #24
0
		public LivePreviewEndedEventArgs (RenderStatus status, Exception exception)
		{
			this.Status = status;
			this.Exception = exception;
		}
예제 #25
0
        public void Render(ScriptPortal.Vegas.Vegas myVegas)
        {
            SetProgressBounds(Count);
            using (UndoBlock undo = new UndoBlock("Render tracks"))
            {
                for (int i = 0; i < Count; i++)
                {
                    var ri = this[i];

                    foreach (var trk in myVegas.Project.Tracks)
                    {
                        trk.Mute = !ri.Tracks.Contains(trk);
                    }

                    // padding
                    if (ri.RenderParams.GetParam <bool>(RenderTags.DoPadding))
                    {
                        if (ri.RenderTemplate.RendererID != myVegas.Renderers.FindByName("Wave (Microsoft)").ID)
                        {
                            ErrorLog(
                                String.Format(
                                    "The region {0} could not be padded. Padded rendering can only be performed on .WAV (PCM) files.",
                                    ri.Region.Label));
                        }
                        else
                        {
                            var paddingTime = Timecode.FromSeconds(ri.PaddingSeconds);
                            if (ri.Start - paddingTime < myVegas.Project.Ruler.StartTime)
                            {
                                ErrorLog(String.Format(
                                             "The region {0} could not be padded. Move your region further into the project.", ri.Region.Label));
                            }
                            else
                            {
                                ri.Start  -= paddingTime;
                                ri.Length += paddingTime;
                                ri.Length += paddingTime;
                            }
                        }
                    }

                    if (File.Exists(ri.FilePath) && ri.RenderParams.GetParam <bool>(RenderTags.DoReadonly))
                    {
                        // check readonly
                        var attr = File.GetAttributes(ri.FilePath);
                        if (attr.IsSet(FileAttributes.ReadOnly))
                        {
                            File.SetAttributes(ri.FilePath, attr & ~FileAttributes.ReadOnly);
                        }
                    }
                    SetProgress(i);
                    SetProgressStatus("Rendering " + ri.FilePath);
                    RenderStatus status = myVegas.Render(ri.FilePath, ri.RenderTemplate, ri.Start, ri.Length);
                    if (status != RenderStatus.Complete)
                    {
                        ErrorLog(String.Format("{0} raised error {1}", ri.FilePath, status.ToString()));
                    }
                    else
                    {
                        // file successfully rendered

                        // strip padding
                        if (ri.RenderParams.GetParam <bool>(RenderTags.DoPadding))
                        {
                            WaveFile.StripPadding(ri.FilePath, ri.PaddingSeconds);
                        }
                    }
                }
                foreach (ScriptPortal.Vegas.Track trk in myVegas.Project.Tracks)
                {
                    trk.Mute = false;
                }
                undo.Cancel = true;                 // we didn't really do anything useful.
            }
        }
예제 #26
0
    public void FromVegas(Vegas vegas)
    {
        if (vegas.Project.Length.ToMilliseconds() == 0)
        {
            return;
        }
        SetDllDirectory(VegasDir + "\\Script Depends");
        string RegKey = "HKEY_CURRENT_USER\\Software\\Sony Creative Software\\Vegas Pro\\frameserver";
        int    AddBuffer = 1; int RenderLoop = 1; string outputDirectory = "";

        try {
            AddBuffer       = (int)Registry.GetValue(RegKey, "AddBuffer", 1);
            RenderLoop      = (int)Registry.GetValue(RegKey, "RenderLoopRegion", 1);
            outputDirectory = (string)Registry.GetValue(RegKey, "TempDir", "");
        } catch {}
        string outDirDefualt = Environment.GetEnvironmentVariable("TEMP") + "\\frameserver";

        if (outputDirectory == "")
        {
            outputDirectory = outDirDefualt;
        }
        if (!Directory.Exists(outputDirectory))
        {
            try {
                Directory.CreateDirectory(outputDirectory);
            } catch {
                outputDirectory = outDirDefualt;
                Directory.CreateDirectory(outputDirectory);
            }
        }

        // Start virtual file system, AviSynth and HandBrake
        ahktextdll(Unzip(Convert.FromBase64String(StartScriptData)), "", "");
        while (!ahkReady())
        {
            Thread.Sleep(100);
        }
        ahkassign("TempFileDir", outputDirectory);
        ahkassign("AddBuffer", AddBuffer.ToString());
        ahkassign("RegKey", RegKey);
        ahkassign("VegasDir", VegasDir);
        ahkPause("Off");

        Regex videoRendererRegexp = new Regex(@"DebugMode FrameServer", RegexOptions.Compiled | RegexOptions.IgnoreCase);
        Regex videoTemplateRegexp = new Regex(@"Project Default", RegexOptions.Compiled | RegexOptions.IgnoreCase);

        try
        {
            //Add an empty event to first video track to solve frameserver audio bug
            if (AddBuffer > 0)
            {
                foreach (Track CurTrack in vegas.Project.Tracks)
                {
                    if (CurTrack.IsVideo())
                    {
                        TargetTrack = CurTrack;
                        emptyEvent  = new VideoEvent(vegas.Project, vegas.Project.Length, Timecode.FromMilliseconds(1000), null);
                        CurTrack.Events.Add(emptyEvent);
                        break;
                    }
                }
            }
            // Check timeline's loop-region
            Timecode renderStart  = new Timecode();
            Timecode renderLength = vegas.Project.Length;
            if (RenderLoop > 0)
            {
                renderStart = vegas.SelectionStart;
                if (AddBuffer > 0)
                {
                    renderLength = vegas.SelectionLength + Timecode.FromMilliseconds(1000);
                }
                else
                {
                    renderLength = vegas.SelectionLength;
                }
            }

            //Define export path and file name
            string projDir, projName, videoOutputFile;
            string projFile = vegas.Project.FilePath;
            if ((null == projFile) || (0 == projFile.Length))
            {
                projDir  = "";
                projName = "Untitled";
            }
            else
            {
                projDir  = Path.GetDirectoryName(projFile) + Path.DirectorySeparatorChar;
                projName = Path.GetFileNameWithoutExtension(projFile);
            }
            videoOutputFile = outputDirectory + "\\" + OutFileName + ".avi";
            if (null == videoOutputFile)
            {
                throw new Exception("Process terminated");
            }
            Renderer aviRenderer = FindRenderer(videoRendererRegexp, vegas);
            if (null == aviRenderer)
            {
                throw new Exception("Could not find DebugMode FrameServer");
            }

            // Start export
            RenderTemplate videoTemplate = FindRenderTemplate(aviRenderer, videoTemplateRegexp, vegas);
            if (null == videoTemplate)
            {
                throw new Exception("Could not find the render preset defined by the script");
            }
            RenderStatus renderStatus = vegas.Render(videoOutputFile, videoTemplate, renderStart, renderLength);
            if (AddBuffer > 0)
            {
                TargetTrack.Events.Remove(emptyEvent);
            }
        } catch (Exception ex) {
            if (AddBuffer > 0)
            {
                TargetTrack.Events.Remove(emptyEvent);
            }
            MessageBox.Show(ex.ToString());
        }
    }
예제 #27
0
 public void Deliver(RenderStatus status, string result)
 {
     this.Result = result;
     this.Status = status;
 }
예제 #28
0
 public static void PauseRender()
 {
     Play = RenderStatus.Pause;
 }
예제 #29
0
		void FireLivePreviewEndedEvent (RenderStatus status, Exception ex)
		{
			if (Ended != null) {
				var args = new LivePreviewEndedEventArgs (status, ex);
				Ended (this, args);
			}			
		}
예제 #30
0
 public virtual void SetCameraRenderStatusFeedback(Camera camera, RenderStatus renderStatus)
 {
     cameraToRenderStatus[camera] = renderStatus;
 }