Need a script which can render with match project settings using VEGAS

jetdv wrote on 8/15/2024, 8:38 AM

@iEmby How tight of a match does it need to be? And what version of VEGAS are you using?

It looks like the ability to read some template properties was added in VEGAS Pro 19 (older than that can't see the template properties.)

So you could limit the template search to find a match for the video frame size (height and width), framerate, PAR, and field order.

        public void FindAllRenderers()
        {
            int RCount = 0;
            ProjectVideoProperties vidInfo = myVegas.Project.Video;

            try
            {
                foreach (Renderer renderer in myVegas.Renderers)
                {
                    try
                    {
                        foreach (RenderTemplate renderTemplate in renderer.Templates)
                        {
                            if (renderTemplate.IsValid())
                            {
                                if (renderTemplate.VideoWidth == vidInfo.Width &&
                                    renderTemplate.VideoHeight == vidInfo.Height &&
                                    renderTemplate.VideoPixelAspectRatio == vidInfo.PixelAspectRatio &&
                                    renderTemplate.VideoFrameRate == vidInfo.FrameRate &&
                                    renderTemplate.VideoFieldOrder == vidInfo.FieldOrder)
                                {
                                    FullRenderer[RCount] = renderer;
                                    FullTemplate[RCount] = renderTemplate;
                                    cmbRenderType.Items.Add(renderer.Name + " - " + renderTemplate.Name);
                                    RCount++;
                                }
                            }
                        }
                    }
                    catch
                    {
                    }
                }
            }
            catch
            {
            }

            if (cmbRenderType.SelectedIndex < 0)
            {
                cmbRenderType.SelectedIndex = 0;
            }
        }

iEmby wrote on 8/15/2024, 10:35 PM

i want in mp4 format templates AVC/AAC only.

jetdv wrote on 8/16/2024, 9:19 AM

@iEmby Then add another check in the renderers loop to check for that! Here's both Magix AVC and HEVC. I'm guessing you'll want the first one based on your comment.

                foreach (Renderer renderer in myVegas.Renderers)
                {
                    if (renderer.ClassID == "4c184f1e-4d99-4353-9de0-e49da388cb63") //Magix AVC
                    if (renderer.ClassID == "95a8fdac-31fc-4cf6-bd7d-6fae2b99de83") //Magix HEVC

That will limit you to looking at only the Magix AVC (or HEVC - whichever you choose) in the second loop so only that one renderer's templates will be looked at. It's just a matter of restricting the ones you look at.

But there still could be MULTIPLE matches.

iEmby wrote on 8/16/2024, 10:30 AM

@jetdv thanks 😊 sir.. u r always a obstacles breaker for me.

iEmby wrote on 8/23/2024, 3:09 PM

@jetdv sir
how can i also set my bitrate

if (renderTemplate.IsValid() &&
renderTemplate.VideoWidth == vidInfo.Width &&
renderTemplate.VideoHeight == vidInfo.Height &&
renderTemplate.VideoPixelAspectRatio == vidInfo.PixelAspectRatio &&
renderTemplate.VideoFrameRate == vidInfo.FrameRate &&
renderTemplate.VideoFieldOrder == vidInfo.FieldOrder &&
renderTemplate.VideoBitrate == 15000)

i tried this it show no error but still bitrate is so less

jetdv wrote on 8/23/2024, 6:18 PM

@iEmby I see two options: VideoBitrate or TotalBitrate. Both are "long" values. On the renderer I use, the average bitrate is set to 12,000,000. With that in mind, 15,000 seems a little small.

Go through and list all "matching" templates without checking the bitrate and display what the bitrate is for each. I didn't see any as low as 15000 running this:

            ProjectVideoProperties vidInfo = myVegas.Project.Video;

            try
            {
                foreach (Renderer renderer in myVegas.Renderers)
                {
                    try
                    {
                        foreach (RenderTemplate renderTemplate in renderer.Templates)
                        {
                            if (renderTemplate.IsValid())
                            {
                                if (renderTemplate.VideoWidth == vidInfo.Width &&
                                    renderTemplate.VideoHeight == vidInfo.Height &&
                                    renderTemplate.VideoPixelAspectRatio == vidInfo.PixelAspectRatio &&
                                    renderTemplate.VideoFrameRate == vidInfo.FrameRate &&
                                    renderTemplate.VideoFieldOrder == vidInfo.FieldOrder)
                                {
                                    MessageBox.Show(renderer.Name + "-" + renderTemplate.Name + "  videobitrate=" + renderTemplate.VideoBitrate + "  totalbitrate=" + renderTemplate.TotalBitrate);
                                }
                            }
                        }
                    }
                    catch
                    {
                    }
                }
            }
            catch
            {
            }
        }

I did see 12000000 and several other larger values.

iEmby wrote on 8/23/2024, 9:43 PM

(edited) sir i tried your suggestion so on the basis of that i guess i should try this

public RenderTemplate FindMatchingRenderTemplate()
{
    Project project = vegas.Project;
    if (project == null || project.Video == null)
    {
        throw new InvalidOperationException("Project or Project Video properties are not available.");
    }

    ProjectVideoProperties vidInfo = project.Video;

    foreach (Renderer renderer in vegas.Renderers)
    {
        // Check for Magix AVC renderer
        if (renderer.ClassID == new Guid("4c184f1e-4d99-4353-9de0-e49da388cb63"))
        {
            foreach (RenderTemplate template in renderer.Templates)
            {
                if (template.IsValid() &&
                    template.VideoWidth == vidInfo.Width &&
                    template.VideoHeight == vidInfo.Height &&
                    template.VideoPixelAspectRatio == vidInfo.PixelAspectRatio &&
                    template.VideoFrameRate == vidInfo.FrameRate &&
                    template.VideoFieldOrder == vidInfo.FieldOrder &&
                    template.VideoBitrate == 12000000 &&
                    template.TotalBitrate == 12192000)
                {
                    return template;
                }
            }
        }
    }

    // No matching template found
    return null;
}

but it is render only that template which is preset with the stated bitrate

template.VideoBitrate == 12000000 &&
template.TotalBitrate == 12192000)
so it is only for 25fps when i render project with videoinfo 50fps ..

then it shows no template found.

iEmby wrote on 8/23/2024, 9:57 PM

actually the 12000000 - 12192000 is already a preset of 25fps 1920 x 1080 so it render project in this template when my project is at 25fps. but when i choose another fps it shows "No template selected"

iEmby wrote on 8/23/2024, 10:12 PM

i tried this too..

still not working

        public RenderTemplate FindMatchingRenderTemplate(int videoBitrate, int totalBitrate)
        {
            Project project = vegas.Project;
            if (project == null || project.Video == null)
            {
                throw new InvalidOperationException("Project or Project Video properties are not available.");
            }

            ProjectVideoProperties vidInfo = project.Video;

            foreach (Renderer renderer in vegas.Renderers)
            {
                // Check for Magix AVC renderer
                if (renderer.ClassID == new Guid("4c184f1e-4d99-4353-9de0-e49da388cb63"))
                {
                    foreach (RenderTemplate template in renderer.Templates)
                    {
                        if (template.IsValid() &&
                            template.VideoWidth == vidInfo.Width &&
                            template.VideoHeight == vidInfo.Height &&
                            template.VideoPixelAspectRatio == vidInfo.PixelAspectRatio &&
                            template.VideoFrameRate == vidInfo.FrameRate &&
                            template.VideoFieldOrder == vidInfo.FieldOrder)

                        {
                            return template;
                        }
                    }
                }
            }

            // No matching template found
            return null;
        }

and i call it like

FindMatchingRenderTemplate(15000000, 16192000);

iEmby wrote on 8/23/2024, 11:01 PM

@jetdv sir i solved it... with help of ChatGPT .. i just tell ChatGPT that find the template with highest bitrates after matching other video info and prefer NVIDIA > AMD > INTEL > continue

        public RenderTemplate FindMatchingRenderTemplate()
        {
            Project project = vegas.Project;
            if (project == null || project.Video == null)
            {
                throw new InvalidOperationException("Project or Project Video properties are not available.");
            }

            ProjectVideoProperties vidInfo = project.Video;
            RenderTemplate bestTemplate = null;
            long highestVideoBitrate = 0; // Use long to match the type of VideoBitrate
            long highestTotalBitrate = 0; // Use long to match the type of TotalBitrate

            // Variables to track the preferred templates
            RenderTemplate nvidiaTemplate = null;
            RenderTemplate amdTemplate = null;
            RenderTemplate intelTemplate = null;

            foreach (Renderer renderer in vegas.Renderers)
            {
                // Check for Magix AVC renderer
                if (renderer.ClassID == new Guid("4c184f1e-4d99-4353-9de0-e49da388cb63"))
                {
                    foreach (RenderTemplate template in renderer.Templates)
                    {
                        if (template.IsValid() &&
                            template.VideoWidth == vidInfo.Width &&
                            template.VideoHeight == vidInfo.Height &&
                            template.VideoPixelAspectRatio == vidInfo.PixelAspectRatio &&
                            template.VideoFieldOrder == vidInfo.FieldOrder &&
                            template.VideoFrameRate == vidInfo.FrameRate)
                        {
                            // Check if this template has higher bitrates
                            if (template.VideoBitrate > highestVideoBitrate ||
                                (template.VideoBitrate == highestVideoBitrate && template.TotalBitrate > highestTotalBitrate))
                            {
                                bestTemplate = template;
                                highestVideoBitrate = template.VideoBitrate;
                                highestTotalBitrate = template.TotalBitrate;
                            }

                            // Track templates with specific words
                            if (template.Name.IndexOf("NVIDIA", StringComparison.OrdinalIgnoreCase) >= 0)
                            {
                                nvidiaTemplate = template;
                            }
                            else if (template.Name.IndexOf("AMD", StringComparison.OrdinalIgnoreCase) >= 0)
                            {
                                amdTemplate = template;
                            }
                            else if (template.Name.IndexOf("INTEL", StringComparison.OrdinalIgnoreCase) >= 0)
                            {
                                intelTemplate = template;
                            }
                        }
                    }
                }
            }

            // Prefer templates with specific words in the name
            if (nvidiaTemplate != null)
            {
                return nvidiaTemplate;
            }
            if (amdTemplate != null)
            {
                return amdTemplate;
            }
            if (intelTemplate != null)
            {
                return intelTemplate;
            }

            // Return the best matching template if none of the preferred templates are found
            return bestTemplate;
        }