### Complete Video Conversion with MediaToolkit

Source: https://context7.com/aydinadn/mediatoolkit/llms.txt

This example shows how to configure and execute a video conversion using MediaToolkit. It demonstrates setting various video and audio parameters, including resolution, bitrate, frame rate, and sample rate. It also shows how to trim the video by specifying a start time and maximum duration, and how to subscribe to progress and completion events for user feedback.

```csharp
using MediaToolkit;
using MediaToolkit.Model;
using MediaToolkit.Options;
using System;

public class VideoProcessor
{
    public void ProcessVideo(string inputPath, string outputPath)
    {
        var inputFile = new MediaFile { Filename = inputPath };
        var outputFile = new MediaFile { Filename = outputPath };

        using (var engine = new Engine())
        {
            // Get source metadata
            engine.GetMetadata(inputFile);
            Console.WriteLine($"Input: {inputFile.Metadata.Duration} duration");
            Console.WriteLine($"Video: {inputFile.Metadata.VideoData?.FrameSize}");
            Console.WriteLine($"Audio: {inputFile.Metadata.AudioData?.SampleRate}");

            // Configure conversion
            var options = new ConversionOptions
            {
                // Video settings
                VideoSize = VideoSize.Hd720,
                VideoAspectRatio = VideoAspectRatio.R16_9,
                VideoBitRate = 2500,
                VideoFps = 30,
                BaselineProfile = true,  // H.264 baseline for compatibility

                // Audio settings
                AudioSampleRate = AudioSampleRate.Hz44100,
                AudioBitRate = 192,

                // Cut first 60 seconds starting at 10 seconds
                Seek = TimeSpan.FromSeconds(10),
                MaxVideoDuration = TimeSpan.FromSeconds(60)
            };

            // Subscribe to events
            engine.ConvertProgressEvent += (s, e) =>
            {
                var pct = e.ProcessedDuration.TotalSeconds / e.TotalDuration.TotalSeconds * 100;
                Console.Write($"\rConverting: {pct:F0}%");
            };

            engine.ConversionCompleteEvent += (s, e) =>
            {
                Console.WriteLine($"\nComplete! Final size: {e.SizeKb} KB");
            };

            // Execute conversion
            engine.Convert(inputFile, outputFile, options);
        }
    }
}
```

--------------------------------

### Install MediaToolkit via NuGet

Source: https://github.com/aydinadn/mediatoolkit/blob/master/README.md

Use the Package Manager Console to install the MediaToolkit package.

```powershell
PM> Install-Package MediaToolkit
```

--------------------------------

### CutMedia Method

Source: https://context7.com/aydinadn/mediatoolkit/llms.txt

Enables cutting or slicing a portion of media from a specific start position with a defined duration.

```APIDOC
## CutMedia Method

### Description
Allows cutting/slicing a portion of media from a specific start position with a defined duration, useful for extracting clips from longer videos.

### Method
`CutMedia` (within `ConversionOptions`)

### Parameters
#### Request Body (for `ConversionOptions`)
- **startPosition** (TimeSpan) - Required - The starting point of the clip.
- **duration** (TimeSpan) - Required - The duration of the clip to extract.

### Request Example (C#)
```csharp
var inputFile = new MediaFile { Filename = @"C:\Path\To_Video.mp4" };
var outputFile = new MediaFile { Filename = @"C:\Path\To_Clip.mp4" };

using (var engine = new Engine())
{
    engine.GetMetadata(inputFile);
    var options = new ConversionOptions();

    // Cut 25 seconds starting from the 30 second mark
    options.CutMedia(TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(25));

    engine.Convert(inputFile, outputFile, options);
}

// Cut using minutes for longer videos
var options = new ConversionOptions();
options.CutMedia(TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(15)); // Extracts a 15-minute clip starting at the 5-minute mark
```

### Response
No specific response body is detailed, but the operation results in a new media file containing the extracted clip.
```

--------------------------------

### Slice Media Clips with CutMedia

Source: https://context7.com/aydinadn/mediatoolkit/llms.txt

Extracts a segment of media by defining a start position and duration. Requires a configured ConversionOptions object.

```csharp
using MediaToolkit;
using MediaToolkit.Model;
using MediaToolkit.Options;

var inputFile = new MediaFile { Filename = @"C:\Path\To_Video.mp4" };
var outputFile = new MediaFile { Filename = @"C:\Path\To_Clip.mp4" };

using (var engine = new Engine())
{
    engine.GetMetadata(inputFile);

    var options = new ConversionOptions();

    // Cut 25 seconds starting from the 30 second mark
    // First parameter: start position
    // Second parameter: duration to extract
    options.CutMedia(TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(25));

    engine.Convert(inputFile, outputFile, options);
}
```

```csharp
// Cut using minutes for longer videos
var options = new ConversionOptions();
options.CutMedia(TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(15));
// This extracts a 15-minute clip starting at the 5-minute mark
```

--------------------------------

### Cut video to smaller length

Source: https://github.com/aydinadn/mediatoolkit/blob/master/README.md

Extracts a specific segment of a video by defining start time and duration using CutMedia.

```csharp
    var inputFile = new MediaFile {Filename = @"C:\Path\To_Video.flv"};
    var outputFile = new MediaFile {Filename = @"C:\Path\To_Save_ExtractedVideo.flv"};

    using (var engine = new Engine())
    {
        engine.GetMetadata(inputFile);

        var options = new ConversionOptions();
        
        // This example will create a 25 second video, starting from the 
        // 30th second of the original video.
        //// First parameter requests the starting frame to cut the media from.
        //// Second parameter requests how long to cut the video.
        options.CutMedia(TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(25));

        engine.Convert(inputFile, outputFile, options);
    }
```

--------------------------------

### Initialize Engine Class

Source: https://context7.com/aydinadn/mediatoolkit/llms.txt

The Engine class serves as the primary entry point for media operations, supporting both default embedded FFmpeg and custom executable paths.

```csharp
using MediaToolkit;
using MediaToolkit.Model;

// Basic engine initialization (uses embedded FFmpeg)
using (var engine = new Engine())
{
    var inputFile = new MediaFile { Filename = @"C:\Videos\input.mp4" };
    var outputFile = new MediaFile { Filename = @"C:\Videos\output.avi" };
    engine.Convert(inputFile, outputFile);
}

// Custom FFmpeg path initialization
using (var engine = new Engine(@"C:\Tools\ffmpeg.exe"))
{
    var inputFile = new MediaFile { Filename = @"C:\Videos\input.mp4" };
    engine.GetMetadata(inputFile);
    Console.WriteLine($"Duration: {inputFile.Metadata.Duration}");
}
```

--------------------------------

### Configure Video Size and Aspect Ratio

Source: https://context7.com/aydinadn/mediatoolkit/llms.txt

Use ConversionOptions to set predefined video sizes or custom dimensions and aspect ratios.

```csharp
using MediaToolkit;
using MediaToolkit.Model;
using MediaToolkit.Options;

var inputFile = new MediaFile { Filename = @"C:\Path\To_Video.mp4" };
var outputFile = new MediaFile { Filename = @"C:\Path\To_Output.mp4" };

// Convert to 1080p HD with 16:9 aspect ratio
var options = new ConversionOptions
{
    VideoSize = VideoSize.Hd1080,
    VideoAspectRatio = VideoAspectRatio.R16_9
};

using (var engine = new Engine())
{
    engine.Convert(inputFile, outputFile, options);
}

// Custom resolution
var customOptions = new ConversionOptions
{
    VideoSize = VideoSize.Custom,
    CustomWidth = 1920,
    CustomHeight = 1080
};

// Available VideoSize presets: Hd1080, Hd720, Hd480, _4K, _2K, Vga, Svga, Xga, Uxga, Pal, Ntsc, etc.
// Available VideoAspectRatio values: Default, R3_2, R4_3, R5_3, R5_4, R16_9, R16_10, R17_9
```

--------------------------------

### CustomCommand Method

Source: https://context7.com/aydinadn/mediatoolkit/llms.txt

Allows executing raw FFmpeg command line arguments directly, providing full control over FFmpeg capabilities.

```APIDOC
## CustomCommand Method

### Description
Allows executing raw FFmpeg command line arguments directly, providing full control over FFmpeg capabilities not covered by the standard API.

### Method
`CustomCommand`

### Parameters
#### Request Body
- **command** (string) - Required - The raw FFmpeg command string to execute.

### Request Example (C#)
```csharp
using (var engine = new Engine())
{
    // Custom FFmpeg command for complex operations
    engine.CustomCommand(@"-i input.mp4 -vf \"scale=1280:720\" -c:a copy output.mp4");

    // Extract audio only
    engine.CustomCommand(@"-i video.mp4 -vn -acodec libmp3lame -q:a 2 audio.mp3");

    // Add watermark to video
    engine.CustomCommand(@"-i video.mp4 -i watermark.png -filter_complex \"overlay=10:10\" output.mp4");

    // Concatenate multiple videos
    engine.CustomCommand(@"-f concat -safe 0 -i filelist.txt -c copy output.mp4");
}
```

### Response
No specific response body is detailed, but the operation executes the provided FFmpeg command.
```

--------------------------------

### Subscribe to conversion events

Source: https://github.com/aydinadn/mediatoolkit/blob/master/README.md

Hooks into progress and completion events to monitor the conversion process.

```csharp
    public void StartConverting()
    {
        var inputFile = new MediaFile {Filename = @"C:\Path\To_Video.flv"};
        var outputFile = new MediaFile {Filename = @"C:\Path\To_Save_New_Video.mp4"};
        
        using (var engine = new Engine())
        {
            engine.ConvertProgressEvent += ConvertProgressEvent;
            engine.ConversionCompleteEvent += engine_ConversionCompleteEvent;
            engine.Convert(inputFile, outputFile);
        }
    }

    private void ConvertProgressEvent(object sender, ConvertProgressEventArgs e)
    {
        Console.WriteLine("\n------------\nConverting...\n------------");
        Console.WriteLine("Bitrate: {0}", e.Bitrate);
        Console.WriteLine("Fps: {0}", e.Fps);
        Console.WriteLine("Frame: {0}", e.Frame);
        Console.WriteLine("ProcessedDuration: {0}", e.ProcessedDuration);
        Console.WriteLine("SizeKb: {0}", e.SizeKb);
        Console.WriteLine("TotalDuration: {0}\n", e.TotalDuration);
    }
    
    private void engine_ConversionCompleteEvent(object sender, ConversionCompleteEventArgs e)
    {
        Console.WriteLine("\n------------\nConversion complete!\n------------");
        Console.WriteLine("Bitrate: {0}", e.Bitrate);
        Console.WriteLine("Fps: {0}", e.Fps);
        Console.WriteLine("Frame: {0}", e.Frame);
        Console.WriteLine("ProcessedDuration: {0}", e.ProcessedDuration);
        Console.WriteLine("SizeKb: {0}", e.SizeKb);
        Console.WriteLine("TotalDuration: {0}\n", e.TotalDuration);
    }
```

--------------------------------

### Execute Raw FFmpeg Commands with CustomCommand

Source: https://context7.com/aydinadn/mediatoolkit/llms.txt

Runs arbitrary FFmpeg command line arguments. Useful for complex operations not supported by the standard API.

```csharp
using MediaToolkit;

using (var engine = new Engine())
{
    // Custom FFmpeg command for complex operations
    engine.CustomCommand("-i input.mp4 -vf \"scale=1280:720\" -c:a copy output.mp4");

    // Extract audio only
    engine.CustomCommand("-i video.mp4 -vn -acodec libmp3lame -q:a 2 audio.mp3");

    // Add watermark to video
    engine.CustomCommand("-i video.mp4 -i watermark.png -filter_complex \"overlay=10:10\" output.mp4");

    // Concatenate multiple videos
    engine.CustomCommand("-f concat -safe 0 -i filelist.txt -c copy output.mp4");
}
```

--------------------------------

### Configure Audio Sample Rate

Source: https://context7.com/aydinadn/mediatoolkit/llms.txt

Adjust audio quality by setting the AudioSampleRate and AudioBitRate in ConversionOptions.

```csharp
using MediaToolkit;
using MediaToolkit.Model;
using MediaToolkit.Options;

var inputFile = new MediaFile { Filename = @"C:\Path\To_Video.mp4" };
var outputFile = new MediaFile { Filename = @"C:\Path\To_Output.mp4" };

// High quality audio conversion
var options = new ConversionOptions
{
    AudioSampleRate = AudioSampleRate.Hz48000,  // 48 kHz (DVD quality)
    AudioBitRate = 320                          // 320 kbps
};

using (var engine = new Engine())
{
    engine.Convert(inputFile, outputFile, options);
}

// Standard CD quality
var cdQualityOptions = new ConversionOptions
{
    AudioSampleRate = AudioSampleRate.Hz44100,  // 44.1 kHz (CD quality)
    AudioBitRate = 192
};

// Available AudioSampleRate values: Default, Hz22050, Hz44100, Hz48000
```

--------------------------------

### Perform basic video conversion

Source: https://github.com/aydinadn/mediatoolkit/blob/master/README.md

Converts a media file from one format to another using the Engine class.

```csharp
var inputFile = new MediaFile {Filename = @"C:\Path\To_Video.flv"};
var outputFile = new MediaFile {Filename = @"C:\Path\To_Save_New_Video.mp4"};

using (var engine = new Engine())
{
    engine.Convert(inputFile, outputFile);
}
```

--------------------------------

### Convert Media Files

Source: https://context7.com/aydinadn/mediatoolkit/llms.txt

Transcode media between formats using the Convert method, with optional ConversionOptions for fine-tuned output parameters.

```csharp
using MediaToolkit;
using MediaToolkit.Model;
using MediaToolkit.Options;

// Basic format conversion (FLV to MP4)
var inputFile = new MediaFile { Filename = @"C:\Path\To_Video.flv" };
var outputFile = new MediaFile { Filename = @"C:\Path\To_Save_New_Video.mp4" };

using (var engine = new Engine())
{
    engine.Convert(inputFile, outputFile);
}

// Advanced conversion with options
var inputFile = new MediaFile { Filename = @"C:\Path\To_Video.flv" };
var outputFile = new MediaFile { Filename = @"C:\Path\To_Save_New_Video.mp4" };

var conversionOptions = new ConversionOptions
{
    MaxVideoDuration = TimeSpan.FromSeconds(30),
    VideoAspectRatio = VideoAspectRatio.R16_9,
    VideoSize = VideoSize.Hd1080,
    AudioSampleRate = AudioSampleRate.Hz44100,
    VideoBitRate = 4000,  // kbit/s
    AudioBitRate = 192,   // kbit/s
    VideoFps = 30
};

using (var engine = new Engine())
{
    engine.Convert(inputFile, outputFile, conversionOptions);
}
```

--------------------------------

### Convert to Physical Media Formats

Source: https://context7.com/aydinadn/mediatoolkit/llms.txt

Configures conversion to specific standards like DVD or VCD. Uses Target and TargetStandard enums to define output parameters.

```csharp
using MediaToolkit;
using MediaToolkit.Model;
using MediaToolkit.Options;

// Convert to DVD format with PAL standard
var inputFile = new MediaFile { Filename = @"C:\Path\To_Video.flv" };
var outputFile = new MediaFile { Filename = @"C:\Path\To_Save_New_DVD.vob" };

var conversionOptions = new ConversionOptions
{
    Target = Target.DVD,
    TargetStandard = TargetStandard.PAL
};

using (var engine = new Engine())
{
    engine.Convert(inputFile, outputFile, conversionOptions);
}
```

```csharp
// Convert to VCD format with NTSC standard
var vcdOptions = new ConversionOptions
{
    Target = Target.VCD,
    TargetStandard = TargetStandard.NTSC
};

// Available Target values: Default, VCD, SVCD, DVD, DV, DV50
// Available TargetStandard values: Default, PAL, NTSC, FILM
```

--------------------------------

### Retrieve metadata

Source: https://github.com/aydinadn/mediatoolkit/blob/master/README.md

Queries and displays the duration metadata of a media file.

```csharp
var inputFile = new MediaFile {Filename = @"C:\Path\To_Video.flv"};

using (var engine = new Engine())
{
    engine.GetMetadata(inputFile);
}

Console.WriteLine(inputFile.Metadata.Duration);
```

--------------------------------

### Monitor Conversion Progress

Source: https://context7.com/aydinadn/mediatoolkit/llms.txt

Subscribe to ConvertProgressEvent and ConversionCompleteEvent to track status and metrics during the conversion process.

```csharp
using MediaToolkit;
using MediaToolkit.Model;

public class MediaConverter
{
    public void ConvertWithProgress(string inputPath, string outputPath)
    {
        var inputFile = new MediaFile { Filename = inputPath };
        var outputFile = new MediaFile { Filename = outputPath };

        using (var engine = new Engine())
        {
            // Subscribe to progress events
            engine.ConvertProgressEvent += OnConvertProgress;
            engine.ConversionCompleteEvent += OnConversionComplete;

            engine.Convert(inputFile, outputFile);
        }
    }

    private void OnConvertProgress(object sender, ConvertProgressEventArgs e)
    {
        // Calculate percentage
        double percentage = e.ProcessedDuration.TotalSeconds / e.TotalDuration.TotalSeconds * 100;

        Console.WriteLine($"Progress: {percentage:F1}%");
        Console.WriteLine($"  Frame: {e.Frame}");
        Console.WriteLine($"  FPS: {e.Fps}");
        Console.WriteLine($"  Bitrate: {e.Bitrate} kbps");
        Console.WriteLine($"  Size: {e.SizeKb} KB");
        Console.WriteLine($"  Processed: {e.ProcessedDuration} / {e.TotalDuration}");
    }

    private void OnConversionComplete(object sender, ConversionCompleteEventArgs e)
    {
        Console.WriteLine("Conversion Complete!");
        Console.WriteLine($"  Total Frames: {e.Frame}");
        Console.WriteLine($"  Average FPS: {e.Fps}");
        Console.WriteLine($"  Final Size: {e.SizeKb} KB");
        Console.WriteLine($"  Duration: {e.TotalDuration}");
    }
}
```

--------------------------------

### Transcode FLV to MP4 with options

Source: https://github.com/aydinadn/mediatoolkit/blob/master/README.md

Sets specific video and audio parameters such as duration, aspect ratio, and sample rate during transcoding.

```csharp
    var inputFile = new MediaFile {Filename = @"C:\Path\To_Video.flv"};
    var outputFile = new MediaFile {Filename = @"C:\Path\To_Save_New_Video.mp4"};

    var conversionOptions = new ConversionOptions
    {
        MaxVideoDuration = TimeSpan.FromSeconds(30),
        VideoAspectRatio = VideoAspectRatio.R16_9,
        VideoSize = VideoSize.Hd1080,
        AudioSampleRate = AudioSampleRate.Hz44100
    };

    using (var engine = new Engine())
    {
        engine.Convert(inputFile, outputFile, conversionOptions);
    }
```

--------------------------------

### Target and TargetStandard Options

Source: https://context7.com/aydinadn/mediatoolkit/llms.txt

Enables conversion to physical media formats like DVD, VCD, SVCD with automatic application of proper standards (PAL, NTSC, FILM).

```APIDOC
## Target and TargetStandard Options

### Description
Enable conversion to physical media formats like DVD, VCD, SVCD with proper standards (PAL, NTSC, FILM) applied automatically.

### Method
`Convert` (using `ConversionOptions` with `Target` and `TargetStandard` properties)

### Parameters
#### Request Body (for `ConversionOptions`)
- **Target** (Target enum) - Required - The target media format (e.g., `Target.DVD`, `Target.VCD`).
- **TargetStandard** (TargetStandard enum) - Required - The target standard (e.g., `TargetStandard.PAL`, `TargetStandard.NTSC`).

### Request Example (C#)
```csharp
// Convert to DVD format with PAL standard
var inputFile = new MediaFile { Filename = @"C:\Path\To_Video.flv" };
var outputFile = new MediaFile { Filename = @"C:\Path\To_Save_New_DVD.vob" };

var conversionOptions = new ConversionOptions
{
    Target = Target.DVD,
    TargetStandard = TargetStandard.PAL
};

using (var engine = new Engine())
{
    engine.Convert(inputFile, outputFile, conversionOptions);
}

// Convert to VCD format with NTSC standard
var vcdOptions = new ConversionOptions
{
    Target = Target.VCD,
    TargetStandard = TargetStandard.NTSC
};

// Available Target values: Default, VCD, SVCD, DVD, DV, DV50
// Available TargetStandard values: Default, PAL, NTSC, FILM
```

### Response
No specific response body is detailed, but the operation results in a converted media file in the specified format and standard.
```

--------------------------------

### Retrieve Media Metadata

Source: https://context7.com/aydinadn/mediatoolkit/llms.txt

Extract detailed video and audio properties from media files using the GetMetadata method.

```csharp
using MediaToolkit;
using MediaToolkit.Model;

var inputFile = new MediaFile { Filename = @"C:\Path\To_Video.mp4" };

using (var engine = new Engine())
{
    engine.GetMetadata(inputFile);
}

// Access metadata properties
Console.WriteLine($"Duration: {inputFile.Metadata.Duration}");

// Video metadata
if (inputFile.Metadata.VideoData != null)
{
    Console.WriteLine($"Video Format: {inputFile.Metadata.VideoData.Format}");
    Console.WriteLine($"Frame Size: {inputFile.Metadata.VideoData.FrameSize}");
    Console.WriteLine($"Video Bitrate: {inputFile.Metadata.VideoData.BitRateKbs} kbps");
    Console.WriteLine($"FPS: {inputFile.Metadata.VideoData.Fps}");
    Console.WriteLine($"Color Model: {inputFile.Metadata.VideoData.ColorModel}");
}

// Audio metadata
if (inputFile.Metadata.AudioData != null)
{
    Console.WriteLine($"Audio Format: {inputFile.Metadata.AudioData.Format}");
    Console.WriteLine($"Sample Rate: {inputFile.Metadata.AudioData.SampleRate}");
    Console.WriteLine($"Channels: {inputFile.Metadata.AudioData.ChannelOutput}");
    Console.WriteLine($"Audio Bitrate: {inputFile.Metadata.AudioData.BitRateKbs} kbps");
}
```

--------------------------------

### Convert Flash video to DVD

Source: https://github.com/aydinadn/mediatoolkit/blob/master/README.md

Configures conversion options for DVD output using PAL standard.

```csharp
    var inputFile = new MediaFile {Filename = @"C:\Path\To_Video.flv"};
    var outputFile = new MediaFile {Filename = @"C:\Path\To_Save_New_DVD.vob"};

    var conversionOptions = new ConversionOptions
    {
        Target = Target.DVD, 
        TargetStandard = TargetStandard.PAL
    };

    using (var engine = new Engine())
    {
        engine.Convert(inputFile, outputFile, conversionOptions);
    }
```

--------------------------------

### Grab thumbnail from a video

Source: https://github.com/aydinadn/mediatoolkit/blob/master/README.md

Extracts a frame at a specific timestamp from a video file and saves it as an image.

```csharp
var inputFile = new MediaFile {Filename = @"C:\Path\To_Video.flv"};
var outputFile = new MediaFile {Filename = @"C:\Path\To_Save_Image.jpg"};

using (var engine = new Engine())
{
    engine.GetMetadata(inputFile);
    
    // Saves the frame located on the 15th second of the video.
    var options = new ConversionOptions { Seek = TimeSpan.FromSeconds(15) };
    engine.GetThumbnail(inputFile, outputFile, options);
}
```

--------------------------------

### Crop Video Source

Source: https://context7.com/aydinadn/mediatoolkit/llms.txt

Define a CropRectangle within ConversionOptions to extract a specific region from the source video frame.

```csharp
using MediaToolkit;
using MediaToolkit.Model;
using MediaToolkit.Options;

var inputFile = new MediaFile { Filename = @"C:\Path\To_Video.mp4" };
var outputFile = new MediaFile { Filename = @"C:\Path\To_Cropped.mp4" };

var options = new ConversionOptions
{
    SourceCrop = new CropRectangle
    {
        X = 100,      // Start X position (pixels from left)
        Y = 50,       // Start Y position (pixels from top)
        Width = 1280, // Width of crop area
        Height = 720  // Height of crop area
    }
};

using (var engine = new Engine())
{
    engine.Convert(inputFile, outputFile, options);
}
```

--------------------------------

### Extract Video Thumbnails with GetThumbnail

Source: https://context7.com/aydinadn/mediatoolkit/llms.txt

Captures a specific frame from a video file. Requires calling GetMetadata first to ensure duration information is available.

```csharp
using MediaToolkit;
using MediaToolkit.Model;
using MediaToolkit.Options;

var inputFile = new MediaFile { Filename = @"C:\Path\To_Video.mp4" };
var outputFile = new MediaFile { Filename = @"C:\Path\To_Thumbnail.jpg" };

using (var engine = new Engine())
{
    // Get metadata first to know video duration
    engine.GetMetadata(inputFile);

    // Extract frame at the 15 second mark
    var options = new ConversionOptions { Seek = TimeSpan.FromSeconds(15) };
    engine.GetThumbnail(inputFile, outputFile, options);
}
```

```csharp
// Generate thumbnail from middle of video
var inputFile = new MediaFile { Filename = @"C:\Path\To_Video.mp4" };
var outputFile = new MediaFile { Filename = @"C:\Path\To_Thumbnail.png" };

using (var engine = new Engine())
{
    engine.GetMetadata(inputFile);

    // Seek to middle of video
    var midpoint = inputFile.Metadata.Duration.TotalSeconds / 2;
    var options = new ConversionOptions { Seek = TimeSpan.FromSeconds(midpoint) };
    engine.GetThumbnail(inputFile, outputFile, options);
}
```

--------------------------------

### GetThumbnail Method

Source: https://context7.com/aydinadn/mediatoolkit/llms.txt

Extracts a single frame from a video file and saves it as an image. The Seek option allows specifying the frame by timestamp.

```APIDOC
## GetThumbnail Method

### Description
Extracts a single frame from a video file and saves it as an image. Use the Seek option to specify which frame to capture based on timestamp.

### Method
`GetThumbnail`

### Parameters
#### Request Body
- **inputFile** (MediaFile) - Required - The input video file.
- **outputFile** (MediaFile) - Required - The output image file.
- **options** (ConversionOptions) - Optional - Options for thumbnail extraction, including `Seek`.

#### Request Example (C#)
```csharp
var inputFile = new MediaFile { Filename = @"C:\Path\To_Video.mp4" };
var outputFile = new MediaFile { Filename = @"C:\Path\To_Thumbnail.jpg" };

using (var engine = new Engine())
{
    engine.GetMetadata(inputFile);
    var options = new ConversionOptions { Seek = TimeSpan.FromSeconds(15) };
    engine.GetThumbnail(inputFile, outputFile, options);
}
```

### Response
No specific response body is detailed, but the operation results in an image file being created.
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.