How can I fix static noise when converting an OPUS file to WAV using a continuous stream in C#?

The static you’re hearing is most likely because the code is splitting the Ogg/Opus file into chunks and repeatedly creating a new OpusOggReadStream. An Ogg stream must be processed as one contiguous unit so that the header information and page boundaries aren’t lost. In other words, decoding requires a single, full stream rather than splitting the file into fragments.

Here’s what you can do:

1. Read the entire file (or at least use one continuous stream) and create one instance of OpusOggReadStream.
2. Decode each packet and write its samples (which are 16‑bit PCM values) into your output stream.
3. Use NAudio’s WaveFormat (which by default creates 16‑bit) to write a valid WAV file.

Try something like this:

CSHARPCopied
using System.IO;
using System.Threading.Tasks;
using Concentus.Structs;
using Concentus.Oggfile;
using NAudio.Wave;

public async Task ConvertOpusToWavAsync(string inputOpusPath, string outputWavPath)
{
    // Open the entire opus file.
    using var fileStream = File.OpenRead(inputOpusPath);
    using var memoryStream = new MemoryStream();
    await fileStream.CopyToAsync(memoryStream);
    memoryStream.Seek(0, SeekOrigin.Begin);

    // Create the Opus decoder for 48 kHz, 2 channels.
    var decoder = OpusCodecFactory.CreateDecoder(48000, 2);

    // Create a single Ogg stream reader.
    using var oggStream = new OpusOggReadStream(decoder, memoryStream);

    // Create an output stream for PCM data.
    using var pcmStream = new MemoryStream();

    // Decode all available packets.
    while (oggStream.HasNextPacket)
    {
        short[] samples = oggStream.DecodeNextPacket();
        if (samples == null)
            continue;

        // Write 16-bit PCM samples (little-endian) to our MemoryStream.
        // Each sample is a 'short' which is two bytes.
        foreach (short sample in samples)
        {
            byte[] bytes = System.BitConverter.GetBytes(sample);
            pcmStream.Write(bytes, 0, bytes.Length);
        }
    }

    pcmStream.Seek(0, SeekOrigin.Begin);

    // Create a WaveFormat (48000 Hz, 2 channels, 16-bit).
    var waveFormat = new WaveFormat(48000, 16, 2);

    // Wrap our PCM data stream in a RawSourceWaveStream.
    using var rawWaveStream = new RawSourceWaveStream(pcmStream, waveFormat);

    // Write the output to a WAV file.
    WaveFileWriter.CreateWaveFile16(outputWavPath, rawWaveStream);
}

Explanation

• Single Stream for Ogg/Opus
  Instead of reading the file in small chunks and processing each as a separate Ogg stream, the code reads the entire file into a MemoryStream. This way the header and the packet continuity are preserved.

• Decoding and PCM Write
  Each decoded packet (an array of 16‑bit PCM samples) is written to a MemoryStream. Using BitConverter.GetBytes ensures that each short is converted to two bytes in little‑endian format.

• Writing a WAV File
  Once you have the PCM stream, create a RawSourceWaveStream with a properly configured WaveFormat and use NAudio’s WaveFileWriter to write a valid WAV file.

This should yield a WAV file that plays correctly rather than producing static noise because the correct header and packet information are maintained during the decode process.