waveout.cs

本人觉得C#的软件是不需要源代码的

                volLeft = (ushort)(pdwVolume & 0xffff);
                volRight = (ushort)(pdwVolume >> 0x10);
                return Wave.MMSYSERR.NOERROR;
            }

            public void LoadBuffer()
            {
                int index = (this.m_curBlock + 3) % 2;
                lock (this.m_whdr[index])
                {
                    if (this.m_curBlock == (this.m_numBlocks - 1))
                    {
                        this.CreateBuffer(index);
                    }
                    else
                    {
                        this.ReadBuffer(index);
                    }
                    WaveOut.waveOutWrite(this.m_hwo, this.m_whdr[index], (uint)Marshal.SizeOf(this.m_whdr[index]));
                }
            }

            public Wave.MMSYSERR Pause()
            {
                return WaveOut.waveOutPause(this.m_hwo);
            }

            public Wave.MMSYSERR Play(uint curDevice, string fileName, IntPtr hwnd, int bufferSize, ushort volLeft, ushort volRight)
            {
                if (!this.m_playing)
                {
                    if (!File.Exists(fileName))
                    {
                        return Wave.MMSYSERR.ERROR;
                    }
                    FileInfo info = new FileInfo(fileName);
                    if ((info.Attributes & FileAttributes.ReadOnly) != 0)
                    {
                        info.Attributes -= 1;
                    }
                    FileStream input = new FileStream(fileName, FileMode.Open);
                    if (input == null)
                    {
                        return Wave.MMSYSERR.ERROR;
                    }
                    this.m_rdr = new BinaryReader(input);
                    if (this.m_rdr == null)
                    {
                        return Wave.MMSYSERR.ERROR;
                    }
                    this.m_wfmt = new Wave.WAVEFORMATEX();
                    this.m_wfmt.SeekTo(input);
                    this.m_wfmt.Read(this.m_rdr);
                    Wave.MMSYSERR mmsyserr = WaveOut.waveOutOpen(ref this.m_hwo, curDevice, this.m_wfmt, hwnd, 0, 0x10000);
                    if (mmsyserr != Wave.MMSYSERR.NOERROR)
                    {
                        return mmsyserr;
                    }
                    Wave.MMSYSERR mmsyserr2 = WaveOut.waveOutSetVolume(this.m_hwo, 0xffff);
                    if (mmsyserr2 != Wave.MMSYSERR.NOERROR)
                    {
                        return mmsyserr2;
                    }
                    Wave.MMSYSERR mmsyserr3 = waveOutMessage(this.m_hwo.ToInt32(), 0x401, 2, 0xffff);
                    if (mmsyserr3 != Wave.MMSYSERR.NOERROR)
                    {
                        return mmsyserr3;
                    }
                    Wave.MMSYSERR mmsyserr4 = waveOutMessage(this.m_hwo.ToInt32(), 0x400, 2, 0);
                    if (mmsyserr4 != Wave.MMSYSERR.NOERROR)
                    {
                        return mmsyserr4;
                    }
                    WaveOut.SpeakerPhone.Toggle();
                    this.m_dataLength = (uint)(this.m_rdr.BaseStream.Length - 0x2cL);
                    if (bufferSize == 0)
                    {
                        this.m_bufferSize = (int)this.m_dataLength;
                    }
                    else
                    {
                        this.m_bufferSize = bufferSize / 2;
                    }
                    if ((this.m_bufferSize % this.m_wfmt.nBlockAlign) != 0)
                    {
                        this.m_bufferSize += this.m_wfmt.nBlockAlign - (this.m_bufferSize % this.m_wfmt.nBlockAlign);
                    }
                    this.m_numBlocks = (int)(((ulong)this.m_dataLength) / ((ulong)this.m_bufferSize));
                    if ((this.m_numBlocks * this.m_bufferSize) < this.m_dataLength)
                    {
                        this.m_numBlocks++;
                    }
                    this.m_whdr[0] = new Wave.WAVEHDR();
                    this.m_whdr[1] = new Wave.WAVEHDR();
                    mmsyserr = this.ReadBuffer(0);
                    if (mmsyserr != Wave.MMSYSERR.NOERROR)
                    {
                        return mmsyserr;
                    }
                    if (this.m_numBlocks == 1)
                    {
                        this.m_rdr.BaseStream.Close();
                        this.m_rdr.Close();
                        this.m_rdr = null;
                    }
                    this.SetVolume(volLeft, volRight);
                    mmsyserr = WaveOut.waveOutWrite(this.m_hwo, this.m_whdr[0], (uint)Marshal.SizeOf(this.m_whdr[0]));
                    if (mmsyserr != Wave.MMSYSERR.NOERROR)
                    {
                        return mmsyserr;
                    }
                    this.m_curBlock = 0;
                    new Thread(new ThreadStart(this.LoadBuffer)).Start();
                    this.m_playing = true;
                    WaveOut.SpeakerPhone.Toggle();
                }
                return Wave.MMSYSERR.NOERROR;
            }

            protected Wave.MMSYSERR ReadBuffer(int bufIndex)
            {
                uint bufferSize = (uint)this.m_bufferSize;
                if (bufIndex < this.m_numBlocks)
                {
                    uint num2 = (uint)(this.m_rdr.BaseStream.Length - this.m_rdr.BaseStream.Position);
                    if (this.m_bufferSize > num2)
                    {
                        bufferSize = num2;
                    }
                }
                Wave.MMSYSERR mmsyserr = this.m_whdr[bufIndex].Read(this.m_rdr, bufferSize, this.m_wfmt.nBlockAlign);
                if (mmsyserr != Wave.MMSYSERR.NOERROR)
                {
                    return mmsyserr;
                }
                if ((this.m_whdr[bufIndex].dwFlags & 2) == 0)
                {
                    return WaveOut.waveOutPrepareHeader(this.m_hwo, this.m_whdr[bufIndex], (uint)Marshal.SizeOf(this.m_whdr[bufIndex]));
                }
                return Wave.MMSYSERR.NOERROR;
            }

            public Wave.MMSYSERR Resume()
            {
                return WaveOut.waveOutRestart(this.m_hwo);
            }

            public Wave.MMSYSERR SetVolume(ushort volLeft, ushort volRight)
            {
                uint dwVolume = (uint)((volLeft & 0xffff) | (volRight << 0x10));
                return WaveOut.waveOutSetVolume(this.m_hwo, dwVolume);
            }

            public void Stop()
            {
                WaveOut.waveOutReset(this.m_hwo);
                this.m_playing = false;
                if (this.m_rdr != null)
                {
                    this.m_rdr.BaseStream.Close();
                    this.m_rdr.Close();
                    this.m_rdr = null;
                }
                for (int i = 0; i < 2; i++)
                {
                    if (this.m_whdr[i] != null)
                    {
                        lock (this.m_whdr[i])
                        {
                            if (this.m_hwo != IntPtr.Zero)
                            {
                                WaveOut.waveOutUnprepareHeader(this.m_hwo, this.m_whdr[i], (uint)Marshal.SizeOf(this.m_whdr[i]));
                            }
                            this.m_whdr[i].Dispose();
                            this.m_whdr[i] = null;
                        }
                    }
                }
                if (this.m_hwo != IntPtr.Zero)
                {
                    WaveOut.waveOutClose(this.m_hwo);
                }
                this.m_hwo = IntPtr.Zero;
                this.m_wfmt = null;
            }

            [DllImport("coredll.dll")]
            public static extern Wave.MMSYSERR waveOutMessage(int hWaveOut, int msg, int dw1, int dw2);

            public bool Done
            {
                get
                {
                    return !this.m_playing;
                }
            }

            public uint Milliseconds
            {
                get
                {
                    return ((0x3e8 * this.m_dataLength) / this.m_wfmt.nAvgBytesPerSec);
                }
            }
        }

        protected class WAVEOUTCAPS
        {
            private byte[] m_data = null;
            public const uint WAVECAPS_LRVOLUME = 8;
            public const uint WAVECAPS_PITCH = 1;
            public const uint WAVECAPS_PLAYBACKRATE = 2;
            public const uint WAVECAPS_VOLUME = 4;
            private const uint WAVEOUTCAPS_SIZE = 0x54;

            public WAVEOUTCAPS()
            {
                this.m_data = new byte[0x54];
            }

            public static implicit operator byte[](WaveOut.WAVEOUTCAPS caps)
            {
                return caps.m_data;
            }

            public uint dwFormats
            {
                get
                {
                    return BitConverter.ToUInt32(this.m_data, 0x48);
                }
            }

            public uint dwSupport
            {
                get
                {
                    return BitConverter.ToUInt16(this.m_data, 80);
                }
            }

            public uint Size
            {
                get
                {
                    return 0x54;
                }
            }

            public string szPname
            {
                get
                {
                    char[] chArray = new char[0x20];
                    for (int i = 0; i < 0x20; i++)
                    {
                        chArray[i] = (char)BitConverter.ToUInt16(this.m_data, (i * 2) + 8);
                    }
                    return new string(chArray);
                }
            }

            public uint vDriverVersion
            {
                get
                {
                    return BitConverter.ToUInt32(this.m_data, 4);
                }
            }

            public ushort wChannels
            {
                get
                {
                    return BitConverter.ToUInt16(this.m_data, 0x4c);
                }
            }

            public ushort wMid
            {
                get
                {
                    return BitConverter.ToUInt16(this.m_data, 0);
                }
            }

            public ushort wPid
            {
                get
                {
                    return BitConverter.ToUInt16(this.m_data, 2);
                }
            }

            public ushort wReserved1
            {
                get
                {
                    return BitConverter.ToUInt16(this.m_data, 0x4e);
                }
            }
        }
    }
}