using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Drawing;
using System.Diagnostics;
namespace imageJoin
{
class Program
{
/// <summary>
/// Command line for FFMPEG.
/// Explanation: takes video input and renders it with 1 fps and downscaled to a single pixel to an array of png files
/// </summary>
const string CMDLINE = "-i \"{0}\" -lavfi fps=1,scale=1:{2}:flags=lanczos \"{1}\\%06d.png\"";
/// <summary>
/// Main entry of Application
/// </summary>
/// <param name="args">Command line arguments</param>
static void Main(string[] args)
{
Color[] Colors;
string TempDir = GetTempDir("frameband");
#if DEBUG
//in debug mode I use hardcoded information because lazy.
string VideoFile = @"S:\Media\Video\Star Wars\Star Wars IV\Star Wars IV.mkv";
string OutputFile = @"C:\temp\band.png";
string FFmpegFile = @"D:\Programme\VIDEO\ffmpeg\ffmpeg.exe";
bool SingleColor = false;
int Height = 200;
#else
string VideoFile = Ask("Source video file").Trim('"');
string OutputFile = Ask("Destination image file").Trim('"');
string FFmpegFile = @"ffmpeg.exe";
int Height = 0;
while (!int.TryParse("Image Height", out Height) || Height < 1) ;
bool SingleColor = Ask("Use single color [y/n]").ToLower() == "y";
#endif
//Instead of all this ffmpeg path detection crap it would be better to bundle ffmpeg as resource and extract it at runtime.
while (!File.Exists(FFmpegFile))
{
Console.WriteLine("Can't find {0}", FFmpegFile);
FFmpegFile = Ask("ffmpeg.exe file").Trim('"');
}
DateTime Start = DateTime.Now;
//Generate single frames into PNG
//Note: check if input is a video with at least 1 frame at all.
CreateImages(VideoFile, TempDir, FFmpegFile, SingleColor ? 1 : Height);
DateTime VideoGenerated = DateTime.Now;
if (SingleColor)
{
//Extract color information from the PNG images.
//GetFiles is rather slow, especially for a large number of files,
//but it is certainly easier to use than manually using the Windows API
Colors = ExtractColorFromPixel(Directory.GetFiles(TempDir, "*.png"));
//It is possible, that no colors were extracted,
//for example if the input is an audio file.
if (Colors.Length > 0)
{
RenderBand(Colors, OutputFile, Height);
}
else
{
//Probably invalid video file
Console.WriteLine("No frames were extracted");
}
}
else
{
JoinImages(Directory.GetFiles(TempDir, "*.png"), OutputFile);
}
//Remove temporary PNG files.
//Ideally this would be in a try/catch block at the end,
//that loops until it succeeds.
Directory.Delete(TempDir, true);
//Stats for nerds
TimeSpan tsTotal = DateTime.Now.Subtract(Start);
TimeSpan tsVideo = VideoGenerated.Subtract(Start);
TimeSpan tsImage = DateTime.Now.Subtract(VideoGenerated);
Console.WriteLine(@"Done. Durations:
Total: {0:00}:{1:00}:{2:00}
Video: {3:00}:{4:00}:{5:00}
Image: {6:00}:{7:00}:{8:00}",
tsTotal.Hours, tsTotal.Minutes, tsTotal.Seconds,
tsVideo.Hours, tsVideo.Minutes, tsVideo.Seconds,
tsImage.Hours, tsImage.Minutes, tsImage.Seconds);
#if DEBUG
Console.WriteLine("#END");
//Flush key buffer
while (Console.KeyAvailable)
{
Console.ReadKey();
}
Console.ReadKey();
#endif
}
/// <summary>
/// Renders colors into a frame band
/// </summary>
/// <param name="Colors">List of colors</param>
/// <param name="DestinationFile">Destination image file name</param>
/// <param name="Height">Height of band</param>
private static void RenderBand(Color[] Colors, string DestinationFile, int Height)
{
using (Bitmap Output = new Bitmap(Colors.Length, Height))
{
//if height is 1, then use SetPixel
if (Height == 1)
{
for (int i = 0; i < Colors.Length; i++)
{
Output.SetPixel(i, 0, Colors[i]);
//This actually slows down the application quite a lot.
Console.Write('-');
}
}
else
{
using (Graphics G = Graphics.FromImage(Output))
{
//Note: Setting G.InterpolationMode to a "cheap" value has no effect,
//as it is only used for scaling.
//Creating a 1 pixel high image and then scale the height up does not increases the speed.
for (int i = 0; i < Colors.Length; i++)
{
//Why is this an IDisposable?
using (Pen P = new Pen(Colors[i]))
{
//Drawing a line is by far faster than setting individual pixels.
G.DrawLine(P, new Point(i, 0), new Point(i, Height - 1));
//This actually slows down the application quite a lot.
Console.Write('-');
}
}
}
}
//This detects the image format from the extension
//See System.Drawing.Imaging.ImageFormat enumeration for supported types.
Output.Save(DestinationFile);
Console.WriteLine();
}
}
/// <summary>
/// Create an array of frame images from a video file
/// </summary>
/// <param name="Video">Video file</param>
/// <param name="ImagePath">Path to hold frame band images</param>
/// <param name="FFmpeg">ffmpeg executable path</param>
/// <param name="Height">Height of generated frame bands.</param>
private static void CreateImages(string Video, string ImagePath, string FFmpeg, int Height)
{
using (Process P = Process.Start(FFmpeg, string.Format(CMDLINE, Video, ImagePath, Height)))
{
//Instead of just waiting, spawn the Process hidden and show the progress of stderr.
//I have some code for this already, but was too lazy to go and copy it.
P.WaitForExit();
}
}
/// <summary>
/// Extracts Color information from the top left pixel
/// </summary>
/// <param name="Files">List of files</param>
/// <returns>List of pixel colors</returns>
private static Color[] ExtractColorFromPixel(string[] Files)
{
List<Color> Colors = new List<Color>();
foreach (string s in Files)
{
Bitmap I = null;
try
{
//Ironically Bitmap.FromFile comes from the Image class and will return an Image object,
//but it is fully compatible with the Bitmap type so we just cast.
I = (Bitmap)Bitmap.FromFile(s);
}
catch
{
//I never had this happen but better add an error resolver.
//In this case, we just ignore that frame.
Console.Write('X');
continue;
}
using (I)
{
//Extract image color
Colors.Add(I.GetPixel(0, 0));
//This actually slows down the application quite a lot.
Console.Write('.');
}
}
Console.WriteLine();
return Colors.ToArray();
}
/// <summary>
/// Joins an array of images horizontally
/// </summary>
/// <param name="Files">List of images</param>
/// <param name="OutputFile">Destination File</param>
private static void JoinImages(string[] Files, string OutputFile)
{
int x = 0;
int Height = 0;
using (Image I = Image.FromFile(Files[0]))
{
Height = I.Height;
}
using (Bitmap B = new Bitmap(Files.Length, Height))
{
using (Graphics G = Graphics.FromImage(B))
{
foreach(string Name in Files)
{
using (Image I = Image.FromFile(Name))
{
G.DrawImageUnscaled(I, new Point(x++, 0));
}
Console.Write('-');
}
}
B.Save(OutputFile);
Console.WriteLine();
}
}
/// <summary>
/// Prints a line of text and asks for input
/// </summary>
/// <param name="p">Text to show. Will append colon and space</param>
/// <returns>Line input</returns>
private static string Ask(string p)
{
Console.Write("{0}: ", p);
return Console.ReadLine();
}
/// <summary>
/// Attempts to create a temporary folder
/// </summary>
/// <param name="Dirname">Name of the folder to create</param>
/// <returns>Full path of folder created</returns>
static string GetTempDir(string Dirname)
{
int i = 0;
string TempRoot = Path.Combine(Path.GetTempPath(), Dirname + "_");
while (true)
{
string current = string.Format("{0}{1}", TempRoot, i++);
try
{
Directory.CreateDirectory(current);
return current;
}
catch
{
//you can increase i here instead if you want.
}
}
}
}
}
Comments
0 B
|👍
/👎