My script has been moderately stable for a while now so I figured I'd publish it. Not that anyone but me is likely to want to use it... but more as an example Vegas scripting project developed in Visual Studio 19. Keep in mind this is my first stab at Visual Studio, c#, and a large scale script like this. Still many things I don't know how to accomplish efficiently so any feedback would be greatly appreciated.

Just copied all the Visual Studio project directories to GitHub... that's a first for me too:

https://github.com/hv60604/AutoBench/tree/main

@Howard-Vigorita

Regarding graphics card info, here's a method that extracts that information. Rather than writing to a string, I'd first create a List<string> where you simply add entries to the list. Then set the datasource for your combobox to the list and the user has an option to select which GPU was being used.

private void GetGraphics()
    {
        ManagementScope scope = new ManagementScope("\\\\.\\ROOT\\cimv2");
        ObjectQuery query = new ObjectQuery("SELECT * FROM Win32_VideoController");
        ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query);
        ManagementObjectCollection queryCollection = searcher.Get();
        string graphicsCard = "";
        foreach (ManagementObject mo in queryCollection)
        {
            foreach (PropertyData property in mo.Properties)
            {
                if (property.Name == "Description")
                {
                    graphicsCard += property.Value.ToString() + " ";
                }
            }
        }
        MessageBox.Show(graphicsCard);
    }

Edit: Here's the link to the original stackoverflow thread. https://stackoverflow.com/questions/37524111/how-to-find-active-in-use-graphic-cards-c-sharp

Thanks, @wwaag That looks more elegant than the explicit array assignment I used where I overloaded both gpu and decoder combo box lists and selection indexes into the same function:

        public void FindAllGraphicsCards()
        {
            // find graphic card names
            string[] Decoder;
            List<string> list = new List<string>();
            using (var searcher = new ManagementObjectSearcher("select * from Win32_VideoController"))
            {
                foreach (ManagementObject obj in searcher.Get())
                {
                    list.Add((String)obj["Name"]);
                }
            }
            GraphicsCards = list.ToArray();
            Decoder = list.ToArray();
            // allow for selecting no decoder
            cmbDecoder.Items.Add("none");
            foreach (String card in GraphicsCards)
            {
                cmbGraphicsCard.Items.Add(card);
                cmbDecoder.Items.Add(card);
            }
            // default gpu to the last graphics card and decoder to first
            cmbGraphicsCard.SelectedIndex = GraphicsCards.Length-1;
            cmbDecoder.SelectedIndex = 1;
        }

My code might be a little confusing as some diagnostic lines that have been commented out. Some other lines that didn't work out for me should probably be deleted instead of just commented out. For instance, the release version of the script doesn't actually call a MessageBox.Show on any of the hardware detected... that only appears in the FindGpuDrivers() function that I used during development to probe what gpu data the ManagementObjectSearcher could come up with. The calling line for that function has been commented out. I kept the function in because others might find it useful... but I should probably explain that in a comment... [EDIT: just did all that. hv]

Btw, any chance you know how to capture the elapsed-time variable shown in the Vegas render box? I'm still stuck on that. This script returns slightly longer run times because the timer starts when render is requested and ends when control returns. That elapsed time includes any file system delays that occur before rendering actually begins, which seem to be between 1 and 3 seconds at times. My only work around is to run renders a 2nd time after a programmed cooling-off period and record the lower elapsed time.

@Howard-Vigorita

"Btw, any chance you know how to capture the elapsed-time variable shown in the Vegas render box?"

No, I have no idea. There doesn't appear to be any type of rendering log that I can find. There is a Vegasaur render assistant tool that also provides render times that don't agree with the Vegas times. Just my nickel's worth, but I wouldn't worry about the 1 to 3 sec difference. I can render 5 times and get 5 different durations, so which one is the best estimate? You could take averages, but I hardly think it would be worth the time or effort given the multitude of things that can affect render performance for any given run.

@wwaag That's interesting. I just looked at SeMW. It doesn't report elapsed time on its progress screen. But it does report average fps. Which if divided into the total frame count when render completes seems to nail the Vegas-reported elapsed time. Maybe I've been looking for the wrong thing. Perhaps running a timer in conjunction with calls to the RenderStatusEventHandler is the trick.

I too looked at SEMW extensions and was surprised it didn't report elapsed time. Here's an example of how I check for the render being cancelled.

var status = myVegas.Render(tempWavFile, waveTemplate, loopStart, loopLengthAudio);
if (status == RenderStatus.Canceled)
    {
        DialogResult result1 = MessageBox.Show("Direct Render from Vegas Cancelled", "Stop", MessageBoxButtons.OK, MessageBoxIcon.Stop);
        goto endofcode;
    }
WriteLogFile("Temp audio render completed from Vegas");

If you start your stopwatch just before the start and end it when status becomes Render.Completed, that may work.

@wwaag Thanks for taking the time to look at this. But I think the problem is that once I transfer control to Vegas to do the render, my script does not regain control to do anything till it's either done or cancelled. So I have to start the timer before I transfer control. Here's how I do it:

                            timer.Start();
                            DoRender(FullFileName, myRenderer, myTemplate, RStart, RLength, false, false);
                            timer.Stop();

The DoRender() function is basically from @jetdv tutorials and it indeed polls RenderStatus on return:

        public void DoRender(string fileName, Renderer rndr, RenderTemplate rndrTemplate, Timecode start, Timecode length, bool IncMarkers, bool SetStretch)
        {
            // ...
            // transfer control to Vegas requesting render
            RenderStatus status = myVegas.Render(args);
            //...
            if (status == RenderStatus.Canceled)
            {
                MessageBox.Show("User canceled");
                btnRender.Text = "Render";
                mymsg.Text = "User cancelled.";
                mymsg.Refresh();
                btnRender.Refresh();
                exit = true;
                return;
            }
       }

I think the best approach might be some kind of background worker that is created right before DoRender() is called, tests the render progress and starts the timer when it actually begins, perhaps when progress is >0%, stops the timer when progress hits 100%, and is then destroyed. Rather than the way I'm doing it. Ha, ha, easy for me to say, having never messed with background workers in Vegas before.

Also thinking a more simplified approach more within my skill set might be to call myVegas.Render(args) twice, setting the RLength arg to zero the first time before setting it to the actual length and starting the timer for the real deal. Kind of hokey but might minimize any file system setup delays that only seem to precede the very 1st render no matter how many different projects I do in the same run.