'' DLL konnte nicht geladen werden 'mfplat.dll': Das angegebene Modul konnte nicht gefunden werden. (Ausnahme von HRESULT: 0x8007007E) "

Question

Hier habe ich den folgenden Code zum Konvertieren einer WAV-formatierten Audiodatei zum Entfernen von unerwünschten Rauschen und bessere Qualität. Dieser Code funktioniert gut in lokalen Host .. aber während Code im IIS-Server laufen, habe ich ein Fehler wie:

kann nicht DLL 'mfplat.dll' laden. Das angegebene Modul wurde nicht gefunden werden konnte (Ausnahme von HRESULT: 0x8007007E)

und ich bin mit NAudio Codec für Audio Jeder findet eine Lösung dafür, bitte helfen Sie mir, es zu lösen ..

static void ConversionTest(string _outfilename, string _infilename) 
    { 
     try 
     { 
      using(var reader = new MediaFoundationReader(_infilename)) 
      { 
       // Create a wave format for 16-bit pcm at 8000 samples per second. 
       int channels = reader.WaveFormat.Channels; 
       int rate = 8000; 
       int rawsize = 2; 
       int blockalign = rawsize * channels; // this is the size of one sample. 
       int bytespersecond = rate * blockalign; 
       var midformat = 
        WaveFormat.CreateCustomFormat(WaveFormatEncoding.Pcm, 
                rate, 
                channels, 
                bytespersecond, 
                blockalign, 
                rawsize * 8); 

       // And a conversion stream to turn input into 16-bit PCM. 
       var midstream = new MediaFoundationResampler(reader, midformat); 
       //var midstream = new WaveFormatConversionStream(midformat, reader); 

       // The output stream is our custom stream. 
       var outstream = new PcmToALawConversionStream(midstream); 


       WaveFileWriter.CreateWaveFile(_outfilename, outstream); 
      } 
     } 
     catch(Exception _ex) 
     { 
     } 
    } 

    } 

Und hier ist die Klasse, die 16-Bit-PCM in A-Law oder u-Law konvertiert. Am Ende sind Spezialisierungen für A-Law oder u-Gesetz:

/// <summary> 
    /// Encodes 16-bit PCM input into A- or u-Law, presenting the output 
    /// as an IWaveProvider. 
    /// </summary> 
    public class PcmToG711ConversionStream : IWaveProvider 
    { 
     /// <summary>Gets the local a-law or u-law format.</summary> 
     public WaveFormat WaveFormat { get { return waveFormat; } } 

     /// <summary>Returns <paramref name="count"/> encoded bytes.</summary> 
     /// <remarks> 
     /// Note that <paramref name="count"/> is raw bytes. It doesn't consider 
     /// channel counts, etc. 
     /// </remarks> 
     /// <param name="buffer">The output buffer.</param> 
     /// <param name="offset">The starting position in the output buffer.</param> 
     /// <param name="count">The number of bytes to read.</param> 
     /// <returns>The total number of bytes encoded into <paramref name="buffer"/>.</returns> 
     public int Read(byte[] buffer, int offset, int count) 
     { 
      // We'll need a source buffer, twice the size of 'count'. 
      int shortcount = count*2; 
      byte [] rawsource = new byte [shortcount]; 
      int sourcecount = Provider.Read(rawsource, 0, shortcount); 
      int bytecount = sourcecount/2; 
      for(int index = 0; index < bytecount; ++index) 
      { 
       short source = BitConverter.ToInt16(rawsource, index*2); 
       buffer[offset+index] = Encode(source); 
      } 
      return bytecount; 
     } 


     /// <summary> 
     /// Initializes and A-Law or u-Law "WaveStream". The source stream 
     /// must be 16-bit PCM! 
     /// </summary> 
     /// <param name="_encoding">ALaw or MuLaw only.</param> 
     /// <param name="_sourcestream">The input PCM stream.</param> 
     public PcmToG711ConversionStream(WaveFormatEncoding _encoding, 
              IWaveProvider _provider) 
     { 
      Provider = _provider; 
      WaveFormat sourceformat = Provider.WaveFormat; 
      if((sourceformat.Encoding != WaveFormatEncoding.Pcm) && 
       (sourceformat.BitsPerSample != 16)) 
      { 
       throw new NotSupportedException("Input must be 16-bit PCM. Try using a conversion stream."); 
      } 

      if(_encoding == WaveFormatEncoding.ALaw) 
      { 
       Encode = this.EncodeALaw; 
       waveFormat = WaveFormat.CreateALawFormat(_provider.WaveFormat.SampleRate, 
                  _provider.WaveFormat.Channels) ; 

      } 
      else if(_encoding == WaveFormatEncoding.MuLaw) 
      { 
       Encode = this.EncodeMuLaw; 
       waveFormat = WaveFormat.CreateMuLawFormat(_provider.WaveFormat.SampleRate, 
                  _provider.WaveFormat.Channels) ; 
      } 
      else 
      { 
       throw new NotSupportedException("Encoding must be A-Law or u-Law"); 
      } 
     } 


     /// <summary>The a-law or u-law encoder delegate.</summary> 
     EncodeHandler Encode; 
     /// <summary>a-law or u-law wave format.</summary> 
     WaveFormat waveFormat; 
     /// <summary>The input stream.</summary> 
     IWaveProvider Provider; 

     /// <summary>A-Law or u-Law encoder delegate.</summary> 
     /// <param name="_sample">The 16-bit PCM sample to encode.</param> 
     /// <returns>The encoded value.</returns> 
     delegate byte EncodeHandler(short _sample); 

     byte EncodeALaw(short _sample) 
     { 
      return ALawEncoder.LinearToALawSample(_sample); 
     } 
     byte EncodeMuLaw(short _sample) 
     { 
      return MuLawEncoder.LinearToMuLawSample(_sample); 
     } 
    } 


    public class PcmToALawConversionStream : PcmToG711ConversionStream 
    { 
     public PcmToALawConversionStream(IWaveProvider _provider) 
      : base(WaveFormatEncoding.ALaw, _provider) 
     { 
     } 
    } 

    public class PcmToMuLawConversionStream : PcmToG711ConversionStream 
    { 
     public PcmToMuLawConversionStream(IWaveProvider _provider) 
      : base(WaveFormatEncoding.MuLaw, _provider) 
     { 
     } 
    } 
} 

Answer 1

Media Foundation ist eine optionale Funktion auf Windows Server-Editionen, so dass Sie sie installieren. Einige Anweisungen here