Question

我正在尝试在C＃2010中编写一个程序，通过ffmpeg.exe和NeroAACenc.exe将mp3文件转换为m4a格式的音频书。为此，我使用Diagnostics.Process类中的内置将ffmpeg的stdout重定向到我的应用程序中的Nero编码器的stdin。

所有内容似乎都按预期工作，但出于某种原因，StandardOutput.BaseStream ffmpeg在某个时间停止接收数据。该进程不会退出，并且也不会引发ErrorDataReceived事件。生成的输出m4a文件的长度总是约为2分钟。如果我只是将mp3文件编码为临时wav文件而不提供Nero，则同样适用。

我通过命令行尝试了相同的操作，这没有任何问题。

ffmpeg -i test.mp3 -f wav - | neroAacEnc -ignorelength -if - -of test.m4a

有谁能告诉我这里做错了什么？提前谢谢。

class Encoder
{
    private byte[] ReadBuffer = new byte[4096];
    private Process ffMpegDecoder = new Process();
    private Process NeroEncoder = new Process();
    private BinaryWriter NeroInput;

    //Create WAV temp file for testing
    private Stream s = new FileStream("D:\\test\\test.wav", FileMode.Create);
    private BinaryWriter outfile;

    public void Encode()
    {
        ProcessStartInfo ffMpegPSI = new ProcessStartInfo("ffmpeg.exe", "-i D:\\test\\test.mp3 -f wav -");
        ffMpegPSI.UseShellExecute = false;
        ffMpegPSI.CreateNoWindow = true;
        ffMpegPSI.RedirectStandardOutput = true;
        ffMpegPSI.RedirectStandardError = true;
        ffMpegDecoder.StartInfo = ffMpegPSI;

        ProcessStartInfo NeroPSI = new ProcessStartInfo("neroAacEnc.exe", "-if - -ignorelength -of D:\\test\\test.m4a");
        NeroPSI.UseShellExecute = false;
        NeroPSI.CreateNoWindow = true;
        NeroPSI.RedirectStandardInput = true;
        NeroPSI.RedirectStandardError = true;
        NeroEncoder.StartInfo = NeroPSI;

        ffMpegDecoder.Exited += new EventHandler(ffMpegDecoder_Exited);
        ffMpegDecoder.ErrorDataReceived += new DataReceivedEventHandler(ffMpegDecoder_ErrorDataReceived);
        ffMpegDecoder.Start();

        NeroEncoder.Start();
        NeroInput = new BinaryWriter(NeroEncoder.StandardInput.BaseStream);

        outfile = new BinaryWriter(s);

        ffMpegDecoder.StandardOutput.BaseStream.BeginRead(ReadBuffer, 0, ReadBuffer.Length, new AsyncCallback(ReadCallBack), null);

    }

    private void ReadCallBack(IAsyncResult asyncResult)
    {
        int read = ffMpegDecoder.StandardOutput.BaseStream.EndRead(asyncResult);
        if (read > 0)
        {

            NeroInput.Write(ReadBuffer);
            NeroInput.Flush();

            outfile.Write(ReadBuffer);
            outfile.Flush();

            ffMpegDecoder.StandardOutput.BaseStream.Flush();

            ffMpegDecoder.StandardOutput.BaseStream.BeginRead(ReadBuffer, 0, ReadBuffer.Length, new AsyncCallback(ReadCallBack), null);
        }
        else
        {
            ffMpegDecoder.StandardOutput.BaseStream.Close();
            outfile.Close();
        }

    }

    private void ffMpegDecoder_Exited(object sender, System.EventArgs e)
    {
        Console.WriteLine("Exit");
    }

    private void ffMpegDecoder_ErrorDataReceived(object sender, DataReceivedEventArgs errLine)
    {
        Console.WriteLine("Error");
    }

}

Answer 1

我遇到了将二进制数据发送到ffmpeg的StandardInput的类似问题。将RedirectStandardError设置为true时，您必须以某种方式处理它。或者，您可以将其设置为false。

否则，该过程会暂停等待您阅读可能导致问题的StandardError / StandardOutput。

Answer 2

这已经解决了吗？我几周前（2014年11月）刚刚注意到这个问题，我可能有一个解决方案。代码模式如下所示，旨在对二进制stdin和二进制stdout数据进行操作。

在我的计划中，我必须考虑让这一点发挥作用。

stdin，stdout可能代表大量数据。因此，StandardInput和StandardOutput由外部源提供。
Win Forms不处理没有复杂代码开发的异步事件。我通过使用计时器简化了问题。（我相信.NET 4.5作为异步并等待简化异步复杂性，但我还没有使用它们。）
Process.Exited事件似乎不可靠，所以我使用另一种方法来确定“已完成”。我定义方法OnFinish（）来广播“完成”事件。确定“完成”需要两件事：1）Ps必须运行直到退出。使用WaitForExit（）。 2）必须从Ps.StandardOutput读取所有数据。计时器检查Ps已退出，并且Ps.StandardOutput没有更多数据要读取。如果两个条件都为真，则调用OnFinish（）。在其他论坛上有迹象表明，在继续处理StandardOutput数据之前，您必须同时使用WaitForExit（）并读取所有StandardOutput。确保timer.Enabled为true。我还使用了它的默认timer.Interval = 100。
StandardError（因为它不是二进制文件，可能不是那么大）由它自己的事件处理程序处理。并且Commander提供了自己的StandardError并将消息（如果有的话）提供给字符串ErrorMessage。

（显然已观察到）进程被装入Commander对象。所以我不直接使用Process。我使用Commander让Commander以更友好的方式使用Process。

公共班指挥官{

private bool DoneReadingStdOut { get; set; }

private bool DoneWaitingForPs { get; set; }

public string ErrorMessage { get; set; }

public bool IsFinished { get; set; }

private Process Ps { get; set; }

private ProcessPriorityClass m_PriorityClass = ProcessPriorityClass.Normal;
public ProcessPriorityClass PriorityClass {
    get
    {
        return m_PriorityClass;
    }
    set
    {
        m_PriorityClass = value;
    }
}

private MemoryStream m_StdIn = null;
public MemoryStream StandardInput
{
    get { return m_StdIn; }
    set
    {
        m_StdIn = value;
        Ps.StartInfo.RedirectStandardInput = (value == null ? false : true);
    }
}

private MemoryStream m_StdOut = null;
public MemoryStream StandardOutput
{
    get { return m_StdOut; }
    set
    {
        m_StdOut = value;
        Ps.StartInfo.RedirectStandardOutput = (value == null ? false : true);
    }
}

private Timer m_Timer;  // To synchronize asynchronous activity

public Commander(string command, string options)
{
    m_Timer = new Timer();
    m_Timer.Enabled;
    m_Timer.Tick += timer_Tick;
    ErrorMessage = null;
    IsFinished = false;
    Ps = new Process();
    Ps.ErrorDataReceived += Ps_ErrorDataReceived;
    Ps.StartInfo.Arguments = options;
    Ps.StartInfo.CreateNoWindow = true;
    Ps.StartInfo.FileName = command;
    Ps.StartInfo.RedirectStandardError = true;
    Ps.StartInfo.WorkingDirectory = Path.GetDirectoryName(command); // optional
}

public event EventHandler<EventArgs> Finished;
private void OnFinish(EventArgs e)
{
    if (IsFinished) return;
    IsFinished = true;
    if (Finished != null)
    {
        Finished(this, e);
    }
}

public void Run()
{
    Start();
}

public void Run(ref MemoryStream stdin, ref MemoryStream stdout)
{
    StandardInput = stdin;
    StandardOutput = stdout;
    Start();
}

private void Start()
{
    Ps.Start();
    Ps.PriorityClass = m_PriorityClass;
    Ps.BeginErrorReadLine();
    if (StandardInput != null)
    {
        Inject();
    }
    AsyncExtract();
    Ps.WaitForExit();
    DoneWaitingForPs = true;
}

private void Inject()
{
    StandardInput.Position = 0;
    StandardInput.CopyTo(Ps.StandardInput.BaseStream);
    Ps.StandardInput.BaseStream.Close();
}

private byte[] m_StreamData = null;
private int m_StreamDataLength = 8192;
private void AsyncExtract()
{
    if (m_StreamData == null)
    {
        m_StreamData = new byte[m_StreamDataLength];
    }
    Ps.StandardOutput.BaseStream.BeginRead(
            m_StreamData, 0, m_StreamDataLength,
            new AsyncCallBack(StandardOutput_AsyncCallBack),
            null
            );
}

private void StandardOutput_AsyncCallBack(IAsyncResult asyncResult)
{
    int stdoutreadlength = Ps.StandardOutput.BaseStream.EndRead(asyncResult);
    if (stdoutreadlength == 0)
    {
        Ps.StandardOutput.BaseStream.Close();
        DoneReadingStdOut = true;
    }
    else
    {
        StandardOutput.Write(m_StreamData, 0, stdoutreadlength);
        AsyncExtract();
    }
}

private void Ps_ErrorDataReceived(object sender, DataReceivedEventArgs e)
{
    if (e.Data == null) return;
    ErrorMessage += e.Data;
}

private timer_Tick(object sender, EventArgs e)
{
    if (DoneWaitingForPs && DoneReadingStdOut)
    {
        m_Timer.Enabled = false;
        OnFinish(new EventArgs());
    }
}

}

Answer 3

也许这个shell会帮助你

ffmpeg -i tmp/jay001.mp3 -f wav pipe:1 | neroAacEnc -cbr 24000 -hev2 -ignorelength -if - -of tmp/jay001-24.m4a

尝试将ffmpeg的二进制stdout重定向到NeroAacEnc stdin

3 个答案: