public static bool AudioCpuEncoding(FileItem fileItem)
{
try
{
LogManager.AddEncodingMessage("SourceFilePath " + Path.GetFileName(fileItem.SourceFilePath), "Start AudioCpuEncoding");
fileItem.AudioCpuEncodeProcess.StartProcessDateTime();
// Récupérer la durée totale de la vidéo et sa résolution, autorisation encoding
if (!VideoSourceManager.SuccessAnalyseSource(fileItem.FileContainer.SourceFileItem, false, fileItem.AudioCpuEncodeProcess))
{
return(false);
}
// encoding audio de la source
string arguments = $"-y -i {Path.GetFileName(fileItem.SourceFilePath)} -vcodec copy -acodec aac -strict -2 {Path.GetFileName(fileItem.TempFilePath)}";
var ffmpegProcessManager = new FfmpegProcessManager(fileItem, fileItem.AudioCpuEncodeProcess);
ffmpegProcessManager.StartProcess(arguments, VideoSettings.EncodeTimeout);
fileItem.SetVideoAacTempFilePath(fileItem.TempFilePath);
LogManager.AddEncodingMessage("OutputFileName " + Path.GetFileName(fileItem.VideoAacTempFilePath) + " / FileSize " + fileItem.FileSize + " / Format " + fileItem.VideoSize, "End AudioCpuEncoding");
fileItem.AudioCpuEncodeProcess.EndProcessDateTime();
return(true);
}
catch (Exception ex)
{
LogManager.AddEncodingMessage("Video Duration " + fileItem.VideoDuration + " / FileSize " + fileItem.FileSize + " / Progress " + fileItem.AudioCpuEncodeProcess.Progress + " / Exception : " + ex, "Exception AudioCpuEncoding");
fileItem.AudioCpuEncodeProcess.SetErrorMessage("Exception");
TempFileManager.SafeDeleteTempFile(fileItem.TempFilePath);
return(false);
}
}
public static bool AudioVideoCpuEncoding(FileItem fileItem)
{
try
{
FileItem sourceFile = fileItem.FileContainer.SourceFileItem;
LogManager.AddEncodingMessage("SourceFilePath " + Path.GetFileName(sourceFile.SourceFilePath) + " -> " + fileItem.VideoSize, "Start AudioVideoCpuEncoding");
fileItem.AudioVideoCpuEncodeProcess.StartProcessDateTime();
// Récupérer la durée totale de la vidéo et sa résolution, autorisation encoding
if (!VideoSourceManager.SuccessAnalyseSource(sourceFile, false, fileItem.AudioVideoCpuEncodeProcess))
{
return(false);
}
string size = GetSize(fileItem.VideoSize, sourceFile.VideoWidth.Value, sourceFile.VideoHeight.Value);
string arguments = $"-y -i {Path.GetFileName(sourceFile.SourceFilePath)} -pixel_format yuv420p -vf scale={size} -vcodec libx264 -acodec aac -strict -2 {Path.GetFileName(fileItem.TempFilePath)}"; //-strict -2 pour forcer aac sur ubuntu
var ffmpegProcessManager = new FfmpegProcessManager(fileItem, fileItem.AudioVideoCpuEncodeProcess);
ffmpegProcessManager.StartProcess(arguments, VideoSettings.EncodeTimeout);
fileItem.SetOutputFilePath(fileItem.TempFilePath);
LogManager.AddEncodingMessage("OutputFileName " + Path.GetFileName(fileItem.OutputFilePath) + " / FileSize " + fileItem.FileSize + " / Format " + fileItem.VideoSize, "End AudioVideoCpuEncoding");
fileItem.AudioVideoCpuEncodeProcess.EndProcessDateTime();
return(true);
}
catch (Exception ex)
{
LogManager.AddEncodingMessage("Video Duration " + fileItem.VideoDuration + " / FileSize " + fileItem.FileSize + " / Progress " + fileItem.AudioVideoCpuEncodeProcess.Progress + " / Exception : " + ex, "Exception AudioVideoCpuEncoding");
fileItem.AudioVideoCpuEncodeProcess.SetErrorMessage("Exception");
TempFileManager.SafeDeleteTempFile(fileItem.TempFilePath);
return(false);
}
}
public static bool VideoGpuEncoding(FileItem fileItem)
{
try
{
LogManager.AddEncodingMessage("SourceFilePath " + Path.GetFileName(fileItem.VideoAacTempFilePath) + " -> 1:N formats", "Start VideoGpuEncoding");
fileItem.VideoGpuEncodeProcess.StartProcessDateTime();
// Récupérer la durée totale de la vidéo et sa résolution, autorisation encoding
if (!VideoSourceManager.SuccessAnalyseSource(fileItem.FileContainer.SourceFileItem, false, fileItem.VideoGpuEncodeProcess))
{
return(false);
}
// encoding video 1:N formats
//string arguments = $"-y -hwaccel cuvid -vcodec h264_cuvid -vsync 0 -i {Path.GetFileName(fileItem.VideoAacTempFilePath)}";
string arguments = $"-y -i {Path.GetFileName(fileItem.VideoAacTempFilePath)}";
foreach (var item in fileItem.FileContainer.EncodedFileItems)
{
string size = GetSize(item.VideoSize, fileItem.VideoWidth.Value, fileItem.VideoHeight.Value);
string maxRate = GetMaxRate(item.VideoSize);
//arguments += $" -pixel_format yuv420p -vf scale_npp={size} -b:v {maxRate} -maxrate {maxRate} -bufsize {maxRate} -vcodec h264_nvenc -acodec copy {Path.GetFileName(item.TempFilePath)}";
arguments += $" -pixel_format yuv420p -vf scale={size} -b:v {maxRate} -maxrate {maxRate} -bufsize {maxRate} -vcodec h264_nvenc -acodec copy {Path.GetFileName(item.TempFilePath)}";
}
var ffmpegProcessManager = new FfmpegProcessManager(fileItem, fileItem.VideoGpuEncodeProcess);
ffmpegProcessManager.StartProcess(arguments, VideoSettings.EncodeTimeout);
foreach (var item in fileItem.FileContainer.EncodedFileItems)
{
item.SetOutputFilePath(item.TempFilePath);
LogManager.AddEncodingMessage("OutputFileName " + Path.GetFileName(item.OutputFilePath) + " / FileSize " + item.FileSize + " / Format " + item.VideoSize, "End VideoGpuEncoding");
}
fileItem.VideoGpuEncodeProcess.EndProcessDateTime();
TempFileManager.SafeDeleteTempFile(fileItem.VideoAacTempFilePath);
return(true);
}
catch (Exception ex)
{
LogManager.AddEncodingMessage("Video Duration " + fileItem.VideoDuration + " / FileSize " + fileItem.FileSize + " / Progress " + fileItem.VideoGpuEncodeProcess.Progress + " / Exception : " + ex, "Exception VideoGpuEncoding");
fileItem.VideoGpuEncodeProcess.SetErrorMessage("Exception");
foreach (FileItem item in fileItem.FileContainer.EncodedFileItems)
{
TempFileManager.SafeDeleteTempFile(item.TempFilePath);
}
TempFileManager.SafeDeleteTempFile(fileItem.VideoAacTempFilePath);
return(false);
}
}
public static bool Encode(FileItem fileItem)
{
FileItem sourceFile = fileItem.FileContainer.SourceFileItem;
try
{
fileItem.SpriteEncodeProcess.StartProcessDateTime();
LogManager.AddSpriteMessage("SourceFilePath " + Path.GetFileName(fileItem.SourceFilePath), "Start Sprite");
// Récupérer la durée totale de la vidéo et sa résolution, autorisation sprite creation
if (!VideoSourceManager.SuccessAnalyseSource(fileItem, true, fileItem.SpriteEncodeProcess))
{
return(false);
}
int nbImages = VideoSettings.NbSpriteImages;
int heightSprite = VideoSettings.HeightSpriteImages;
// Calculer nb image/s
// si < 100s de vidéo -> 1 image/s
// sinon (nb secondes de la vidéo / 100) image/s
string frameRate = "1";
int duration = sourceFile.VideoDuration.Value;
if (duration > nbImages)
{
frameRate = $"{nbImages}/{duration}"; //frameRate = inverse de image/s
}
int spriteWidth = SizeHelper.GetWidth(sourceFile.VideoWidth.Value, sourceFile.VideoHeight.Value, heightSprite);
string sizeImageMax = $"scale={spriteWidth}:{heightSprite}";
// Extract frameRate image/s de la video
string arguments = $"-y -i {Path.GetFileName(fileItem.SourceFilePath)} -r {frameRate} -vf {sizeImageMax} -f image2 {GetPattern(fileItem.TempFilePath)}";
var ffmpegProcessManager = new FfmpegProcessManager(fileItem, fileItem.SpriteEncodeProcess);
ffmpegProcessManager.StartProcess(arguments, VideoSettings.EncodeGetImagesTimeout);
string[] files = GetListImageFrom(fileItem.TempFilePath); // récupération des images
LogManager.AddSpriteMessage((files.Length - 1) + " images", "Start Combine images");
bool successSprite = CombineBitmap(files.Skip(files.Length - VideoSettings.NbSpriteImages).ToArray(), fileItem.TempFilePath); // création du sprite
TempFileManager.SafeDeleteTempFiles(files); // suppression des images
if (successSprite)
{
fileItem.SetOutputFilePath(fileItem.TempFilePath);
LogManager.AddSpriteMessage("OutputFileName " + Path.GetFileName(fileItem.OutputFilePath) + " / FileSize " + fileItem.FileSize, "End Sprite");
}
else
{
LogManager.AddSpriteMessage("Error while combine images", "Error");
fileItem.SpriteEncodeProcess.SetErrorMessage("Error creation sprite while combine images");
return(false);
}
fileItem.SpriteEncodeProcess.EndProcessDateTime();
return(true);
}
catch (Exception ex)
{
LogManager.AddSpriteMessage("Video Duration " + sourceFile.VideoDuration + " / FileSize " + fileItem.FileSize + " / Progress " + fileItem.SpriteEncodeProcess.Progress + " / Exception : " + ex, "Exception");
fileItem.SpriteEncodeProcess.SetErrorMessage("Exception");
string[] files = GetListImageFrom(fileItem.TempFilePath); // récupération des images
TempFileManager.SafeDeleteTempFiles(files); // suppression des images
return(false);
}
}
public static bool SuccessAnalyseSource(FileItem sourceFile, bool spriteMode, ProcessItem processItem)
{
if (sourceFile == null)
{
throw new ArgumentNullException(nameof(sourceFile));
}
if (sourceFile == null)
{
throw new ArgumentNullException(nameof(sourceFile));
}
if (!sourceFile.IsSource)
{
throw new ArgumentException("Doit être le fichier source", nameof(sourceFile));
}
// Récupérer la durée totale de la vidéo et sa résolution
if (!sourceFile.VideoDuration.HasValue)
{
lock (sourceFile)
{
if (!sourceFile.VideoDuration.HasValue)
{
string imageOutputPath = Path.ChangeExtension(TempFileManager.GetNewTempFilePath(), ".jpeg");
try
{
var ffmpegProcessManager = new FfmpegProcessManager(sourceFile, sourceFile.InfoSourceProcess);
string argumentsImage = $"-y -i {Path.GetFileName(sourceFile.SourceFilePath)} -vf fps=1 -vframes 1 {Path.GetFileName(imageOutputPath)}";
ffmpegProcessManager.StartProcess(argumentsImage, VideoSettings.EncodeGetOneImageTimeout);
using (Image image = Image.FromFile(imageOutputPath))
{
sourceFile.VideoWidth = image.Width;
sourceFile.VideoHeight = image.Height;
}
}
catch (Exception ex)
{
Log(ex.ToString(), "Exception source info", spriteMode);
sourceFile.VideoDuration = -1; //pour ne pas essayer de le recalculer sur une demande de video à encoder
}
TempFileManager.SafeDeleteTempFile(imageOutputPath);
}
}
}
// Si durée totale de vidéo, largeur hauteur non récupéré, on ne peut pas continuer
if (!sourceFile.SuccessGetSourceInfo())
{
string message = "Error while getting duration, height or width.";
Log(message + " FileName : " + Path.GetFileName(sourceFile.SourceFilePath), "Error source info", spriteMode);
if (!spriteMode && sourceFile.IpfsProcess == null)
{
sourceFile.AddIpfsProcess(sourceFile.SourceFilePath);
IpfsDaemon.Instance.Queue(sourceFile);
}
processItem.SetErrorMessage(message);
return(false);
}
int duration = sourceFile.VideoDuration.Value;
Log("SourceVideoDuration " + duration + " / SourceVideoFileSize " + sourceFile.FileSize, "Info source", spriteMode);
// Désactivation encoding et sprite si dépassement de la durée maximale
if (sourceFile.HasReachMaxVideoDurationForEncoding())
{
if (!spriteMode && sourceFile.IpfsProcess == null)
{
sourceFile.AddIpfsProcess(sourceFile.SourceFilePath);
IpfsDaemon.Instance.Queue(sourceFile);
}
processItem.CancelCascade("Dépassement de la durée limite de la vidéo atteinte.");
return(false);
}
return(true);
}
public static bool CheckAndAnalyseSource(FileItem fileItem, bool spriteMode)
{
FileItem sourceFile = fileItem.FileContainer.SourceFileItem;
// Récupérer la durée totale de la vidéo et sa résolution
if (!sourceFile.VideoDuration.HasValue)
{
lock (sourceFile)
{
if (!sourceFile.VideoDuration.HasValue)
{
string imageOutputPath = Path.ChangeExtension(TempFileManager.GetNewTempFilePath(), ".jpeg");
try
{
var ffmpegProcessManager = new FfmpegProcessManager(fileItem);
string argumentsImage = $"-y -i {Path.GetFileName(sourceFile.FilePath)} -vf fps=1 -vframes 1 {Path.GetFileName(imageOutputPath)}";
ffmpegProcessManager.StartProcess(argumentsImage, VideoSettings.EncodeGetOneImageTimeout);
using (Image image = Image.FromFile(imageOutputPath))
{
sourceFile.VideoWidth = image.Width;
sourceFile.VideoHeight = image.Height;
}
}
catch (Exception ex)
{
Log(ex.ToString(), "Exception", spriteMode);
sourceFile.VideoDuration = -1; //pour ne pas essayer de le recalculer sur une demande de video à encoder
}
TempFileManager.SafeDeleteTempFile(imageOutputPath);
}
}
}
// Si durée totale de vidéo, largeur hauteur non récupéré, on ne peut pas continuer
if ((sourceFile.VideoDuration ?? 0) <= 0 || (sourceFile.VideoWidth ?? 0) <= 0 || (sourceFile.VideoHeight ?? 0) <= 0)
{
Log("Error while getting duration, height or width. FileName : " + Path.GetFileName(sourceFile.FilePath), "Error", spriteMode);
fileItem.EncodeErrorMessage = "Error while getting duration, height or width.";
fileItem.CleanFiles();
return(false);
}
int duration = sourceFile.VideoDuration.Value;
Log("SourceVideoDuration " + duration + " / SourceVideoFileSize " + fileItem.FileContainer.SourceFileItem.FileSize, "Info source", spriteMode);
// Désactivation encoding et sprite si dépassement de la durée maximale
if (duration > VideoSettings.MaxVideoDurationForEncoding)
{
fileItem.EncodeErrorMessage = "Disable because duration reach the max limit.";
if (spriteMode)
{
fileItem.FileContainer.DeleteSpriteVideo();
}
else
{
fileItem.FileContainer.EncodedFileItems.Clear();
}
fileItem.CleanFiles();
return(false);
}
return(true);
}
public static bool Encode(FileItem fileItem)
{
string newEncodedFilePath = null;
try
{
fileItem.EncodeProgress = "0.00%";
FileItem sourceFile = fileItem.FileContainer.SourceFileItem;
string sourceFilePath = sourceFile.FilePath;
VideoSize videoSize = fileItem.VideoSize;
LogManager.AddEncodingMessage("SourceFilePath " + Path.GetFileName(sourceFilePath) + " -> " + videoSize, "Start");
// Récupérer la durée totale de la vidéo et sa résolution, autorisation encoding
if (!VideoSourceManager.CheckAndAnalyseSource(fileItem, false))
{
return(false);
}
string size;
string maxRate = string.Empty;
switch (videoSize)
{
case VideoSize.F360p:
{
maxRate = "200k";
Tuple <int, int> finalSize = SizeHelper.GetSize(sourceFile.VideoWidth.Value, sourceFile.VideoHeight.Value, 640, 360);
size = $"{finalSize.Item1}:{finalSize.Item2}";
break;
}
case VideoSize.F480p:
{
maxRate = "500k";
Tuple <int, int> finalSize = SizeHelper.GetSize(sourceFile.VideoWidth.Value, sourceFile.VideoHeight.Value, 854, 480);
size = $"{finalSize.Item1}:{finalSize.Item2}";
break;
}
case VideoSize.F720p:
{
maxRate = "1000k";
Tuple <int, int> finalSize = SizeHelper.GetSize(sourceFile.VideoWidth.Value, sourceFile.VideoHeight.Value, 1280, 720);
size = $"{finalSize.Item1}:{finalSize.Item2}";
break;
}
case VideoSize.F1080p:
{
maxRate = "1600k";
Tuple <int, int> finalSize = SizeHelper.GetSize(sourceFile.VideoWidth.Value, sourceFile.VideoHeight.Value, 1920, 1080);
size = $"{finalSize.Item1}:{finalSize.Item2}";
break;
}
default:
throw new InvalidOperationException("Format non reconnu.");
}
newEncodedFilePath = Path.ChangeExtension(TempFileManager.GetNewTempFilePath(), ".mp4");
string arguments;
if (VideoSettings.GpuEncodeMode)
{
arguments = $"-y -hwaccel cuvid -vcodec h264_cuvid -vsync 0 -i {Path.GetFileName(sourceFilePath)} -vf \"scale_npp={size},format=yuv420p\" -b:v {maxRate} -maxrate {maxRate} -bufsize {maxRate} -vcodec h264_nvenc -acodec copy {Path.GetFileName(newEncodedFilePath)}";
}
else
{
arguments = $"-y -i {Path.GetFileName(sourceFilePath)} -vf \"scale={size},format=yuv420p\" -vcodec libx264 -acodec aac {Path.GetFileName(newEncodedFilePath)}";
}
var ffmpegProcessManager = new FfmpegProcessManager(fileItem);
ffmpegProcessManager.StartProcess(arguments, VideoSettings.EncodeTimeout);
fileItem.FilePath = newEncodedFilePath;
LogManager.AddEncodingMessage("OutputFileName " + Path.GetFileName(newEncodedFilePath) + " / FileSize " + fileItem.FileSize + " / Format " + videoSize, "End Encoding");
fileItem.EncodeProgress = "100.00%";
return(true);
}
catch (Exception ex)
{
LogManager.AddEncodingMessage("Video Duration " + fileItem.VideoDuration + " / FileSize " + fileItem.FileSize + " / Progress " + fileItem.EncodeProgress + " / Exception : " + ex, "Exception");
fileItem.EncodeErrorMessage = "Exception";
TempFileManager.SafeDeleteTempFile(newEncodedFilePath);
fileItem.CleanFiles();
return(false);
}
}
