Ausführen von ffmpeg.exe durch Windows-Dienst schlägt fehl, während mit großen Dateien zu tun

Question

Ich verwende ffmpeg.exe, um Videodateien in FLV-Format zu konvertieren. Zu diesem Zweck verwende ich einen Windows-Dienst, um den Konvertierungsprozess im Hintergrund auszuführen. Beim Versuch, konvertieren große Dateien (ich erlebte es, wenn die Dateigröße> 14MB) durch Windows-Dienst wird es an der Linie stecken, die den Prozess (dh) beginnt.

Aber als ich versuchte, ffmpeg.exe direkt von der Eingabeaufforderung auszuführen, funktionierte es ohne irgendwelche Probleme.

Mein Code in Windows-Dienst ist wie folgt:

private Thread WorkerThread; 
protected override void OnStart(string[] args) 
{ 

    WorkerThread = new Thread(new ThreadStart(StartHandlingVideo)); 
    WorkerThread.Start(); 
} 

protected override void OnStop() 
{ 
    WorkerThread.Abort(); 
} 

private void StartHandlingVideo() 
{ 
    FilArgs = string.Format("-i {0} -ar 22050 -qscale 1 {1}", InputFile, OutputFile); 
    Process proc; 
    proc = new Process(); 

    try 
    { 

    proc.StartInfo.FileName = spath + "\\ffmpeg\\ffmpeg.exe"; 
    proc.StartInfo.Arguments = FilArgs; 
    proc.StartInfo.UseShellExecute = false; 
    proc.StartInfo.CreateNoWindow = false; 
    proc.StartInfo.RedirectStandardOutput = true; 
    proc.StartInfo.RedirectStandardError = true; 

    eventLog1.WriteEntry("Going to start process of convertion"); 

    proc.Start(); 

    string StdOutVideo = proc.StandardOutput.ReadToEnd(); 
    string StdErrVideo = proc.StandardError.ReadToEnd(); 

    eventLog1.WriteEntry("Convertion Successful"); 
    eventLog1.WriteEntry(StdErrVideo);    
} 
catch (Exception ex) 
{ 
    eventLog1.WriteEntry("Convertion Failed"); 
    eventLog1.WriteEntry(ex.ToString());    
} 
finally 
{ 
    proc.WaitForExit(); 
    proc.Close(); 
} 

Wie kann ich aus dieser Situation befreien.

Answer 1

Es scheint, dass Sie einen Deadlock erkannt haben, weil Sie am Ende der beiden umgeleiteten Streams einen synchronen Lesevorgang ausgeführt haben.

Eine Referenz von MSDN:

Es gibt ein ähnliches Problem, wenn Sie alle Texte sowohl von der Standardausgabe und Standardfehlerströme lesen. Der folgende C# -Code, zum Beispiel , führt eine Leseoperation an beiden Streams durch.

// Do not perform a synchronous read to the end of both 
// redirected streams. 
// string output = p.StandardOutput.ReadToEnd(); 
// string error = p.StandardError.ReadToEnd(); 
// p.WaitForExit(); 
// Use asynchronous read operations on at least one of the streams. 
p.BeginOutputReadLine(); 
string error = p.StandardError.ReadToEnd(); 
p.WaitForExit(); 

Das Codebeispiel vermeidet die Deadlock Zustand durch asynchrones Ausführen Operationen auf den StandardOutput Stream lesen. Eine Deadlock-Bedingung führt , wenn der übergeordnete Prozess ruft p.StandardOutput.ReadToEnd gefolgt von p.StandardError.ReadToEnd und der Kind-Prozess schreibt genug Text seinen Fehlerstrom füllen. Der übergeordnete Prozess würde unbegrenzt auf warten, bis der untergeordnete Prozess seinen StandardOutput-Stream schließt. Der untergeordnete Prozess würde unbegrenzt auf warten, damit der übergeordnete Server den vollständigen StandardError-Stream lesen kann.

Sie können die asynchronen Leseoperationen verwenden, um diese Abhängigkeiten und ihr Deadlock-Potenzial zu vermeiden. Alternativ können Sie die Deadlock-Bedingung vermeiden, indem Sie zwei Threads erstellen und die Ausgabe jedes Streams in einem separaten Thread lesen.