Get thumbnail image of video file in C#

Question

I want to display thumbnails for videos listed on my site, I want to fetch a single frame from a video (from a particular time) and display them as thumbnails.

I have try this http://ramcrishna.blogspot.com/2008/09/playing-videos-like-youtube-and.html but is not working.

Is that possible using .NET C#?

Answer 1

FFMpeg is a right tool that can be used to extract video frame at some position. You can invoke ffmpeg.exe as mentioned above or just use existing .NET wrapper (like Video converter for .NET (it's free) to get thumbnail with just one line of code:

var ffMpeg = new NReco.VideoConverter.FFMpegConverter();
ffMpeg.GetVideoThumbnail(pathToVideoFile, thumbJpegStream,5);

Answer 2

You can programmatically execute FFmpeg to generate a thumbnail image file. Then open the image file to use it however you wish.

Here is some sample code:

public static Bitmap GetThumbnail(string video, string thumbnail)
{
    var cmd = "ffmpeg  -itsoffset -1  -i " + '"' + video + '"' + " -vcodec mjpeg -vframes 1 -an -f rawvideo -s 320x240 " + '"' + thumbnail + '"';

    var startInfo = new ProcessStartInfo
    {
        WindowStyle = ProcessWindowStyle.Hidden,
        FileName = "cmd.exe",
        Arguments = "/C " + cmd
    };

    var process = new Process
    {
        StartInfo = startInfo
    };

    process.Start();
    process.WaitForExit(5000);

    return LoadImage(thumbnail);
}

static Bitmap LoadImage(string path)
{
    var ms = new MemoryStream(File.ReadAllBytes(path));
    return (Bitmap)Image.FromStream(ms);
}

Answer 3

For people don't want to use FFMpeg as its trouble in Commercial software. I have an old solution here:

ShellFile shellFile = ShellFile.FromFilePath(VideoFileName);
Bitmap bm = shellFile.Thumbnail.Bitmap;

Then you will get a Bitmap object that can be used in drawing. If you want a file, just do:

bm.Save(fileName, System.Drawing.Imaging.ImageFormat.Jpeg);

if you want a BitmapImage that you can use it in Xaml binding. just transfer the Bitmap to BitmapImage. Here is an example:

public static BitmapImage ConvertBitmapToBitmapImage(Bitmap bitmap)
        {
            MemoryStream ms = new MemoryStream();
            bitmap.Save(ms, System.Drawing.Imaging.ImageFormat.Bmp);
            BitmapImage image = new BitmapImage();
            image.BeginInit();
            ms.Seek(0, SeekOrigin.Begin);
            image.StreamSource = ms;
            image.EndInit();

            return image;
        }

Answer 4

Xabe.FFmpeg - free (for non-commercial use), open source and cross-platform library. Provides fluent API to FFmpeg. Generating thumbnail from video in Xabe.F

    string output = Path.Combine(Path.GetTempPath(), Guid.NewGuid() + FileExtensions.Png);
    IConversionResult result = await Conversion.Snapshot(Resources.Mp4WithAudio, output, TimeSpan.FromSeconds(0))
                                               .Start();

It requires FFmpeg executables like in other answer but you can download it by

    FFmpeg.GetLatestVersion();

Full documentation available here - Xabe.FFmpeg Documentation

Answer 5

 [HttpPost]
        [Route("UploadImages")]
        public HttpResponseMessage Post()
        {
            HttpResponseMessage response = new HttpResponseMessage();
            var httpRequest = HttpContext.Current.Request;
            if (httpRequest.Files.Count > 0)
            {
                var docfiles = new List<string>();
                foreach (string file in httpRequest.Files)
                {
                    var postedFile = httpRequest.Files[file];
                    var filePath1 = HttpContext.Current.Server.MapPath("~/ImgFolder/" + postedFile.FileName);

                    Stream strm = postedFile.InputStream;

                    CreateThumbnail(strm, postedFile.FileName);

                    Compressimage(strm, filePath1, postedFile.FileName);


                }
                response = Request.CreateResponse(HttpStatusCode.Created, docfiles);
            }
            else
            {
                response = Request.CreateResponse(HttpStatusCode.BadRequest);
            }
            return response;
        }
        public static void **CreateThumbnail**(Stream sourcePath, string filename)
        {
            Image image = Image.FromStream(sourcePath);
            Image thumb = image.GetThumbnailImage(120, 120, () => false, IntPtr.Zero);
             var filePath1 = HttpContext.Current.Server.MapPath("~/Thumbnail/" + filename);

             thumb.Save(filePath1 + filename);

        }

        public static void Compressimage(Stream sourcePath, string targetPath, String filename)  
        {  


            try  
            {  
                using (var image = Image.FromStream(sourcePath))  
                {  
                    float maxHeight = 900.0f;  
                    float maxWidth = 900.0f;  
                    int newWidth;  
                    int newHeight;  
                    string extension;  
                    Bitmap originalBMP = new Bitmap(sourcePath);  
                    int originalWidth = originalBMP.Width;  
                    int originalHeight = originalBMP.Height;  

                    if (originalWidth > maxWidth || originalHeight > maxHeight)  
                    {  

                        // To preserve the aspect ratio  
                        float ratioX = (float)maxWidth / (float)originalWidth;  
                        float ratioY = (float)maxHeight / (float)originalHeight;  
                        float ratio = Math.Min(ratioX, ratioY);  
                        newWidth = (int)(originalWidth * ratio);  
                        newHeight = (int)(originalHeight * ratio);  
                    }  
                    else  
                    {  
                        newWidth = (int)originalWidth;  
                        newHeight = (int)originalHeight;  

                    }  
                    Bitmap bitMAP1 = new Bitmap(originalBMP, newWidth, newHeight);  
                    Graphics imgGraph = Graphics.FromImage(bitMAP1);  
                    extension = Path.GetExtension(targetPath);  
                    if (extension == ".png" || extension == ".gif")  
                    {  
                        imgGraph.SmoothingMode = SmoothingMode.AntiAlias;  
                        imgGraph.InterpolationMode = InterpolationMode.HighQualityBicubic;  
                        imgGraph.DrawImage(originalBMP, 0, 0, newWidth, newHeight);  


                        bitMAP1.Save(targetPath, image.RawFormat);  

                        bitMAP1.Dispose();  
                        imgGraph.Dispose();  
                        originalBMP.Dispose();  
                    }  
                    else if (extension == ".jpg")  
                    {  

                        imgGraph.SmoothingMode = SmoothingMode.AntiAlias;  
                        imgGraph.InterpolationMode = InterpolationMode.HighQualityBicubic;  
                        imgGraph.DrawImage(originalBMP, 0, 0, newWidth, newHeight);  
                        ImageCodecInfo jpgEncoder = GetEncoder(ImageFormat.Jpeg);  
                        Encoder myEncoder = Encoder.Quality;  
                        EncoderParameters myEncoderParameters = new EncoderParameters(1);  
                        EncoderParameter myEncoderParameter = new EncoderParameter(myEncoder, 50L);  
                        myEncoderParameters.Param[0] = myEncoderParameter;  
                        bitMAP1.Save(targetPath, jpgEncoder, myEncoderParameters);  

                        bitMAP1.Dispose();  
                        imgGraph.Dispose();  
                        originalBMP.Dispose();  

                    }  


                }  

            }  
            catch (Exception)  
            {  
                throw;  

            }  
        }  


        public static ImageCodecInfo GetEncoder(ImageFormat format)  
        {  

            ImageCodecInfo[] codecs = ImageCodecInfo.GetImageDecoders();  

            foreach (ImageCodecInfo codec in codecs)  
            {  
                if (codec.FormatID == format.Guid)  
                {  
                    return codec;  
                }  
            }  
            return null;  
        }