Esempio n. 1
0
        public WaveFormat CalculateMaxThroughputSoundFormat(int m_Device)
        {
            WaveFormat m_Format;

            // automatically select mode gathering more bytes
            int MaxThroughput = 0, MaxThroughputChannel = 0, MaxThroughputRate = 0, MaxThroughputDepth = 0;
            for (int r = 0; r < SampleRateList.Length; r++)
            {
                for (int c = 0; c < ChannelList.Length; c++)
                {
                    for (int d = 0; d < SampleDepthList.Length; d++)
                    {
                        m_Format = new WaveFormat(SampleRateList[r], SampleDepthList[d], ChannelList[c]);
                        m_Format.wFormatTag = (short)WaveFormats.Pcm;
                        IntPtr m_WaveIn;
                        int waveResult = WaveNative.waveInOpen(out m_WaveIn, m_Device, m_Format, null, 0, WaveNative.WAVE_FORMAT_DIRECT | WaveNative.WAVE_FORMAT_QUERY);
                        if (waveResult == WaveNative.MMSYSERR_NOERROR)
                        {
                            if (m_Format.nAvgBytesPerSec > MaxThroughput)
                            {
                                MaxThroughput = m_Format.nAvgBytesPerSec;
                                MaxThroughputChannel = m_Format.nChannels;
                                MaxThroughputRate = m_Format.nSamplesPerSec;
                                MaxThroughputDepth = m_Format.wBitsPerSample;
                            }
                        }
                    }
                }
            }

            m_Format = new WaveFormat(MaxThroughputRate, MaxThroughputDepth, MaxThroughputChannel);
            m_Format.wFormatTag = (short)WaveFormats.Pcm;

            return m_Format;
        }
Esempio n. 2
0
    /// <summary>
    /// Create WmaStream with specific format for for uncompressed audio data.
    /// </summary>
    /// <param name="FileName">Name of asf file</param>
    /// <param name="OutputFormat">WaveFormat that define the desired audio data format</param>
    public WmaStream(string FileName, WaveFormat OutputFormat)

    {
      m_Reader = WM.CreateSyncReader(WMT_RIGHTS.WMT_RIGHT_NO_DRM);

      try

      {
        m_Reader.Open(FileName);

        Init(OutputFormat);
      }

      catch

      {
        try

        {
          m_Reader.Close();
        }

        catch {}

        m_Reader = null;

        throw;
      }
    }
Esempio n. 3
0
    /// <summary>
    /// Create the writer indicating Metadata information
    /// </summary>
    /// <param name="output"><see cref="System.IO.Stream"/> Where resulting WMA string will be written</param>
    /// <param name="format">PCM format of input data received in <see cref="WmaWriter.Write"/> method</param>
    /// <param name="profile">IWMProfile that describe the resulting compressed stream</param>
    /// <param name="MetadataAttributes">Array of <see cref="Yeti.WMFSdk.WM_Attr"/> structures describing the metadata information that will be in the result stream</param>
    public WmaWriter(Stream output, WaveFormat format, IWMProfile profile, WM_Attr[] MetadataAttributes)
      : base(output, format)
		{
			m_Writer = WM.CreateWriter();
      IWMWriterAdvanced wa = (IWMWriterAdvanced)m_Writer;
      wa.AddSink((IWMWriterSink)this);
      m_Writer.SetProfile(profile);
      uint inputs;
      m_Writer.GetInputCount(out inputs);
      if (inputs == 1)
      {
        IWMInputMediaProps InpProps;
        Guid type;
        m_Writer.GetInputProps(0, out InpProps);
        InpProps.GetType(out type);
        if (type == MediaTypes.WMMEDIATYPE_Audio)
        {
          WM_MEDIA_TYPE mt;
          mt.majortype = MediaTypes.WMMEDIATYPE_Audio;
          mt.subtype = MediaTypes.WMMEDIASUBTYPE_PCM;
          mt.bFixedSizeSamples	= true;
          mt.bTemporalCompression = false;
          mt.lSampleSize	= (uint)m_InputDataFormat.nBlockAlign;
          mt.formattype	= MediaTypes.WMFORMAT_WaveFormatEx;
          mt.pUnk	= IntPtr.Zero;
          mt.cbFormat	= (uint)Marshal.SizeOf(m_InputDataFormat);

          GCHandle h = GCHandle.Alloc(m_InputDataFormat, GCHandleType.Pinned);
          try
          {
            mt.pbFormat	= h.AddrOfPinnedObject();
            InpProps.SetMediaType(ref mt);
          }
          finally
          {
            h.Free();
          }
          m_Writer.SetInputProps(0, InpProps);
          if ( MetadataAttributes != null )
          {
            WMHeaderInfo info = new WMHeaderInfo((IWMHeaderInfo)m_Writer);
            foreach(WM_Attr attr in MetadataAttributes)
            {
              info.SetAttribute(attr);
            }
            info = null;
          }
          m_Writer.BeginWriting();
          m_Profile = profile;
        }
        else
        {
          throw new ArgumentException("Invalid profile", "profile");
        }
      }
      else
      {
        throw new ArgumentException("Invalid profile", "profile");
      }
		}
Esempio n. 4
0
        public WaveInRecorder(
			int device, 
			WaveFormat format, 
			int bufferSize, 
			int bufferCount, 
			BufferDoneEventHandler doneProc)
        {
            m_DoneProc = doneProc;
            WaveInHelper.Try(
                WaveNative.waveInOpen(
                    out m_WaveIn,
                    device, format,
                    m_BufferProc,
                    0,
                    WaveNative.CALLBACK_FUNCTION));
            AllocateBuffers(bufferSize, bufferCount);
            for (int i = 0; i < bufferCount; i++)
            {
                SelectNextBuffer();
                m_CurrentBuffer.Record();
            }
            WaveInHelper.Try(WaveNative.waveInStart(m_WaveIn));
            m_Thread = new Thread(new ThreadStart(ThreadProc));
            m_Thread.Start();
        }
Esempio n. 5
0
 public tRNG(int buffer_size)
 {
     BufferSize = buffer_size;
     SoundDevice = WaveNative.WAVE_MAPPER;
     SoundFormat = CalculateMaxThroughputSoundFormat(SoundDevice);
     SoundBuffer = new List<byte>();
 }
Esempio n. 6
0
 /// <summary>
 /// A constructor with this signature must be implemented by descendants. 
 /// <see cref="System.Runtime.Serialization.ISerializable"/> for more information
 /// </summary>
 /// <param name="info">The <see cref="System.Runtime.Serialization.SerializationInfo"/> where is the serialized data.</param>
 /// <param name="context">The source (see <see cref="System.Runtime.Serialization.StreamingContext"/>) for this serialization.</param>
 protected AudioWriterConfig(SerializationInfo info, StreamingContext context)
 {
   int rate = info.GetInt32("Format.Rate");
   int bits = info.GetInt32("Format.Bits");
   int channels = info.GetInt32("Format.Channels");
   m_Format = new WaveFormat(rate, bits, channels);
 }
Esempio n. 7
0
    public WaveWriter(Stream Output, WaveFormat Format, uint AudioDataSize)
      : base(Output, Format)

    {
      m_AudioDataSize = AudioDataSize;

      WriteWaveHeader();
    }
Esempio n. 8
0
    /// <summary>
    /// Create an instance of WmaWriterConfig specifying the writer input format and the ouput profile
    /// </summary>
    /// <param name="format">Input data format</param>
    /// <param name="profile">Output profile</param>
    public WmaWriterConfig(WaveFormat format, IWMProfile profile)
      : base(format)

    {
      WMProfile prf = new WMProfile(profile);

      m_ProfileData = prf.ProfileData;
    }
Esempio n. 9
0
 public WaveOutPlayer(int device, WaveFormat format, int bufferSize, int bufferCount, BufferFillEventHandler fillProc)
 {
     m_zero = format.wBitsPerSample == 8 ? (byte)128 : (byte)0;
     m_FillProc = fillProc;
     WaveOutHelper.Try(WaveNative.waveOutOpen(out m_WaveOut, device, format, m_BufferProc, 0, WaveNative.CALLBACK_FUNCTION));
     AllocateBuffers(bufferSize, bufferCount);
     m_Thread = new Thread(new ThreadStart(ThreadProc));
     m_Thread.Start();
 }
Esempio n. 10
0
 public WaveWriter(Stream Output, WaveFormat Format)
   :base(Output, Format)
 {
   if ( !OutStream.CanSeek )
   {
     throw new ArgumentException("The stream must supports seeking if AudioDataSize is not supported", "Output");
   }
   OutStream.Seek(WaveHeaderSize+8, SeekOrigin.Current);
 }
Esempio n. 11
0
        public void Initialize(AudioFile file, AudioWave wave)
        {
            _file = file;
            _wave = wave;

            _format = new WaveFormat(_wave.SamplesPerSecond, 16, 1);

            _lastBlock = -1;
            _looped = false;

            _state = new DviAdpcmDecoder.AdpcmState();
            _leftOverBuffer = null;
        }
Esempio n. 12
0
 public void SetInput(MemoryStream input, WaveFormat format)
 {
     if (this.IsRunning)
         this.Stop();
     try
     {
         m_Format = format;
         m_AudioStream = input;
     }
     catch (Exception e)
     {
         Debug.WriteLine(e.Message + e.StackTrace);
     }
 }
Esempio n. 13
0
		private void ReadHeader()
		{
			BinaryReader Reader = new BinaryReader(m_Stream);
			if (ReadChunk(Reader) != "RIFF")
				throw new Exception("Invalid file format");

			Reader.ReadInt32(); // File length minus first 8 bytes of RIFF description, we don't use it

			if (ReadChunk(Reader) != "WAVE")
				throw new Exception("Invalid file format");

			if (ReadChunk(Reader) != "fmt ")
				throw new Exception("Invalid file format");

			int len = Reader.ReadInt32();
			if (len < 16) // bad format chunk length
				throw new Exception("Invalid file format");

			m_Format = new WaveFormat(22050, 16, 2); // initialize to any format
			m_Format.wFormatTag = Reader.ReadInt16();
			m_Format.nChannels = Reader.ReadInt16();
			m_Format.nSamplesPerSec = Reader.ReadInt32();
			m_Format.nAvgBytesPerSec = Reader.ReadInt32();
			m_Format.nBlockAlign = Reader.ReadInt16();
			m_Format.wBitsPerSample = Reader.ReadInt16(); 

			// advance in the stream to skip the wave format block 
			len -= 16; // minimum format size
			while (len > 0)
			{
				Reader.ReadByte();
				len--;
			}

			// assume the data chunk is aligned
			while(m_Stream.Position < m_Stream.Length && ReadChunk(Reader) != "data")
				;

			if (m_Stream.Position >= m_Stream.Length)
				throw new Exception("Invalid file format");

			m_Length = Reader.ReadInt32();
			m_DataPos = m_Stream.Position;

			Position = 0;
		}
Esempio n. 14
0
        public void PutSample(WaveDataType type)
        {
            int ret;
            int size = type.size;
            int rate = type.sample_rate == 0 ? 44100 : type.sample_rate;
            int bit = type.bit_per_sample == 0 ? 16 : type.bit_per_sample;
            int channel = type.channel == 0 ? 2 : type.channel;
            if (waveOut == IntPtr.Zero)
            {
                WaveLib.WaveFormat fmt = new WaveLib.WaveFormat(rate, bit, channel);
                ret = WaveNative.waveOutOpen(out waveOut, -1, fmt, null, 0, WaveNative.CALLBACK_NULL);
                if (ret != WaveNative.MMSYSERR_NOERROR)
                    throw new Exception("can not open wave device");
            }


            queue.Enqueue(type);
        }
Esempio n. 15
0
		public void ReadHeader()
		{
            Position = 0;

			BinaryReader Reader = new BinaryReader(m_Stream);
            var errorCaused = ReadChunk(Reader);
            if (errorCaused != "RIFF")
				throw new Exception("Invalid file format");

			Reader.ReadInt32(); // File length minus first 8 bytes of RIFF description, we don't use it

			if (ReadChunk(Reader) != "WAVE")
				throw new Exception("Invalid file format");

			if (ReadChunk(Reader) != "fmt ")
				throw new Exception("Invalid file format");

			int FormatLength = Reader.ReadInt32();
      if ( FormatLength < 16) // bad format chunk length
				throw new Exception("Invalid file format");

			m_Format = new WaveFormat(22050, 16, 2); // initialize to any format
			m_Format.wFormatTag = Reader.ReadInt16();
			m_Format.nChannels = Reader.ReadInt16();
			m_Format.nSamplesPerSec = Reader.ReadInt32();
			m_Format.nAvgBytesPerSec = Reader.ReadInt32();
			m_Format.nBlockAlign = Reader.ReadInt16();
			m_Format.wBitsPerSample = Reader.ReadInt16(); 
      if ( FormatLength > 16)
      {
        m_Stream.Position += (FormatLength-16);
      }
			// assume the data chunk is aligned
			while(m_Stream.Position < m_Stream.Length && ReadChunk(Reader) != "data")
				;

			if (m_Stream.Position >= m_Stream.Length)
				throw new Exception("Invalid file format");

			m_Length = Reader.ReadInt32();
			m_DataPos = m_Stream.Position;

			Position = 0;
		}
Esempio n. 16
0
        public Form1()
        {
            InitializeComponent();

            format = new WaveFormat(SampleRate, BitRate, Canales);
            osc1 = new Oscilador();
            osc2 = new Oscilador();
            osc3 = new Oscilador();

            Osc1_TrackBarAmplitud.Value = (int)osc1.Amplitud;
            Osc2_TrackBarAmplitud.Value = (int)osc2.Amplitud;
            Osc3_TrackBarAmplitud.Value = (int)osc3.Amplitud;

            Osc1_TrackBarFrecuencia.Value = (int)osc1.Frecuencia;
            Osc2_TrackBarFrecuencia.Value = (int)osc2.Frecuencia;
            Osc3_TrackBarFrecuencia.Value = (int)osc3.Frecuencia;

            trackBarVolumen.Value = (int)(Volumen * 100);
        }
Esempio n. 17
0
 /// <summary>
 /// Create a Mp3Writer with specific MP3 format
 /// </summary>
 /// <param name="Output">Stream that will hold the MP3 resulting data</param>
 /// <param name="InputDataFormat">PCM format of input data</param>
 /// <param name="Mp3Config">Desired MP3 config</param>
 public Mp3Writer(Stream Output, WaveFormat InputDataFormat, BE_CONFIG Mp3Config)
   :base(Output, InputDataFormat)
 {
   try
   {
     m_Mp3Config = Mp3Config;
     uint LameResult = Lame_encDll.beInitStream(m_Mp3Config, ref m_InputSamples, ref m_OutBufferSize, ref m_hLameStream);
     if ( LameResult != Lame_encDll.BE_ERR_SUCCESSFUL)
     {
       throw new ApplicationException(string.Format("Lame_encDll.beInitStream failed with the error code {0}", LameResult));
     }
     m_InBuffer = new byte[m_InputSamples*2]; //Input buffer is expected as short[]
     m_OutBuffer = new byte[m_OutBufferSize];
   }
   catch
   {
     base.Close();
     throw;
   }
 }
Esempio n. 18
0
        public void PutSample(WaveDataType type)
        {
            int ret;
            int size    = type.size;
            int rate    = type.sample_rate == 0 ? 44100 : type.sample_rate;
            int bit     = type.bit_per_sample == 0 ? 16 : type.bit_per_sample;
            int channel = type.channel == 0 ? 2 : type.channel;

            if (waveOut == IntPtr.Zero)
            {
                WaveLib.WaveFormat fmt = new WaveLib.WaveFormat(rate, bit, channel);
                ret = WaveNative.waveOutOpen(out waveOut, -1, fmt, null, 0, WaveNative.CALLBACK_NULL);
                if (ret != WaveNative.MMSYSERR_NOERROR)
                {
                    throw new Exception("can not open wave device");
                }
            }


            queue.Enqueue(type);
        }
Esempio n. 19
0
        private void PlayUsingWaveOut(AudioFrame frame)
        {
            var type = frame.WaveDate;
            int ret;
            int size    = type.size;
            int rate    = type.sample_rate == 0 ? 44100 : type.sample_rate;
            int bit     = type.bit_per_sample == 0 ? 16 : type.bit_per_sample;
            int channel = type.channel == 0 ? 2 : type.channel;

            if (waveOut == IntPtr.Zero)
            {
                WaveLib.WaveFormat fmt = new WaveLib.WaveFormat(rate, bit, channel);
                ret = WaveNative.waveOutOpen(out waveOut, -1, fmt, null, 0, WaveNative.CALLBACK_NULL);
                if (ret != WaveNative.MMSYSERR_NOERROR)
                {
                    throw new Exception("can not open wave device");
                }
            }


            queue.Enqueue(type);
            //ret = WriteWaveOut(frame);
        }
Esempio n. 20
0
        void Go()
        {
            int samplerate = 16000;
            int bits = 16;  // 8 or 16
            int channels = 1;  // 1 or 2

            filewriter = new WavFileWriter("out.wav", samplerate, bits, channels);

            WaveFormat fmt = new WaveFormat(samplerate, bits, channels);

            // devicenumber, wavformat, buffersize, callback
            int buffersize = 16384;
            WaveInRecorder rec = new WaveInRecorder(-1, fmt, buffersize, this.DataArrived);
            tmparray = new byte[buffersize];

            Console.WriteLine("Recording - press Enter to end");
            Console.ReadLine();
            rec.Close();

            filewriter.Close();

            Console.WriteLine("Bye");
        }
Esempio n. 21
0
        static public string Stop()
        {
            WaveLib.WaveFormat m_Format = new WaveLib.WaveFormat(44100, 16, 2);
            if (m_Recorder != null)
            {
                try
                {
                    // chunksize is length of wave data and the header.
                    long chunksize = RecorderOutputStream.Length + 36;

                    // writing wave header and data
                    System.IO.BinaryWriter bw = new BinaryWriter(fs);

                    WriteChars(bw, "RIFF");
                    bw.Write((int)chunksize);
                    WriteChars(bw, "WAVEfmt ");
                    bw.Write((int)16);
                    bw.Write(m_Format.wFormatTag);
                    bw.Write(m_Format.nChannels);
                    bw.Write(m_Format.nSamplesPerSec);
                    bw.Write(m_Format.nAvgBytesPerSec);
                    bw.Write(m_Format.nBlockAlign);
                    bw.Write(m_Format.wBitsPerSample);
                    WriteChars(bw, "data");
                    bw.Write(RecorderOutputStream.Length);
                    bw.Write(RecorderOutputStream.ToArray());
                    bw.Close();
                    fs.Close();
                    m_Recorder.Dispose();
                }
                finally
                {
                    m_Recorder = null;
                }
            }
            return filename_;
        }
Esempio n. 22
0
        public WaveInRecorder(int device, WaveFormat format, int bufferSize, int bufferCount, BufferDoneEventHandler doneProc)
        {
            try
            {
                EncoderWorking = false;
                m_DoneProc = doneProc;
                WaveInHelper.Try(WaveNative.waveInOpen(out m_WaveIn, device, format, m_BufferProc, 0, WaveNative.CALLBACK_FUNCTION));
                AllocateBuffers(bufferSize, bufferCount);
                for (int i = 0; i < bufferCount; i++)
                {
                    SelectNextBuffer();
                    m_CurrentBuffer.Record();
                }
                WaveInHelper.Try(WaveNative.waveInStart(m_WaveIn));
                m_Thread = new Thread(new ThreadStart(ThreadProc));
                m_Thread.Name = "WaveInRecorder Thread :  ThreadProc()";
                m_Thread.Start();
                EncoderWorking = true;
            }
            catch(Exception )
            {

            }
        }
Esempio n. 23
0
 public ushort nQuality; // Quality Setting, HIGH BYTE should be NOT LOW byte, otherwhise quality=5
 // FUTURE USE, SET TO 0, align strucutre to 331 bytes
 //[ MarshalAs( UnmanagedType.ByValArray, SizeConst=255-4*4-2 )]
 //public byte[]   btReserved;//[255-4*sizeof(DWORD) - sizeof( WORD )];
 public LHV1(WaveFormat format, uint MpeBitRate)
 {
   if (format.wFormatTag != (short)WaveFormats.Pcm)
   {
     throw new ArgumentOutOfRangeException("format", "Only PCM format supported");
   }
   if (format.wBitsPerSample != 16)
   {
     throw new ArgumentOutOfRangeException("format", "Only 16 bits samples supported");
   }
   dwStructVersion = 1;
   dwStructSize = (uint)Marshal.SizeOf(typeof (BE_CONFIG));
   switch (format.nSamplesPerSec)
   {
     case 16000:
     case 22050:
     case 24000:
       dwMpegVersion = MPEG2;
       break;
     case 32000:
     case 44100:
     case 48000:
       dwMpegVersion = MPEG1;
       break;
     default:
       throw new ArgumentOutOfRangeException("format", "Unsupported sample rate");
   }
   dwSampleRate = (uint)format.nSamplesPerSec; // INPUT FREQUENCY
   dwReSampleRate = 0; // DON'T RESAMPLE
   switch (format.nChannels)
   {
     case 1:
       nMode = MpegMode.MONO;
       break;
     case 2:
       nMode = MpegMode.STEREO;
       break;
     default:
       throw new ArgumentOutOfRangeException("format", "Invalid number of channels");
   }
   switch (MpeBitRate)
   {
     case 32:
     case 40:
     case 48:
     case 56:
     case 64:
     case 80:
     case 96:
     case 112:
     case 128:
     case 160: //Allowed bit rates in MPEG1 and MPEG2
       break;
     case 192:
     case 224:
     case 256:
     case 320: //Allowed only in MPEG1
       if (dwMpegVersion != MPEG1)
       {
         throw new ArgumentOutOfRangeException("MpsBitRate", "Bit rate not compatible with input format");
       }
       break;
     case 8:
     case 16:
     case 24:
     case 144: //Allowed only in MPEG2
       if (dwMpegVersion != MPEG2)
       {
         throw new ArgumentOutOfRangeException("MpsBitRate", "Bit rate not compatible with input format");
       }
       break;
     default:
       throw new ArgumentOutOfRangeException("MpsBitRate", "Unsupported bit rate");
   }
   dwBitrate = MpeBitRate; // MINIMUM BIT RATE
   nPreset = LAME_QUALITY_PRESET.LQP_NORMAL_QUALITY; // QUALITY PRESET SETTING
   dwPsyModel = 0; // USE DEFAULT PSYCHOACOUSTIC MODEL 
   dwEmphasis = 0; // NO EMPHASIS TURNED ON
   bOriginal = 1; // SET ORIGINAL FLAG
   bWriteVBRHeader = 0;
   bNoRes = 0; // No Bit resorvoir
   bCopyright = 0;
   bCRC = 0;
   bEnableVBR = 0;
   bPrivate = 0;
   bStrictIso = 0;
   dwMaxBitrate = 0;
   dwVbrAbr_bps = 0;
   nQuality = 0;
   nVbrMethod = VBRMETHOD.VBR_METHOD_NONE;
   nVBRQuality = 0;
 }
Esempio n. 24
0
 public static extern int waveOutOpen(out IntPtr hWaveOut, int uDeviceID, WaveFormat lpFormat, WaveDelegate dwCallback, int dwInstance, int dwFlags);
Esempio n. 25
0
 /// <summary>
 /// Create the writer without metadata Information
 /// </summary>
 /// <param name="output"><see cref="System.IO.Stream"/> Where resulting WMA string will be written</param>
 /// <param name="format">PCM format of input data received in <see cref="WmaWriter.Write"/> method</param>
 /// <param name="profile">IWMProfile that describe the resulting compressed stream</param>
 public WmaWriter(Stream output, WaveFormat format, IWMProfile profile)
   :this(output, format, profile, null)
 {
 }
Esempio n. 26
0
        static public void Start()
        {
            Stop();
            try
            {
                String filename = "recording";
                String ending = ".wav";

                // iterate the filename
                while (File.Exists(filename + counter + ending))
                {
                    counter++;
                }

                filename_ = filename + counter.ToString() + ending;
                // create a new file and wave recorder
                fs = new FileStream(filename + counter + ending, System.IO.FileMode.Create);
                RecorderOutputStream = new MemoryStream();
                WaveLib.WaveFormat fmt = new WaveLib.WaveFormat(44100, 16, 2);
                m_Recorder = new WaveLib.WaveInRecorder(-1, fmt, 16384, 3, new WaveLib.BufferDoneEventHandler(DataArrived));

            }
            catch
            {
                Stop();
                throw;
            }
        }
Esempio n. 27
0
 public BE_CONFIG(WaveFormat format)
   : this(format, 128) {}
Esempio n. 28
0
 public BE_CONFIG(WaveFormat format, uint MpeBitRate)
 {
   this.dwConfig = BE_CONFIG_LAME;
   this.format = new Format(format, MpeBitRate);
 }
Esempio n. 29
0
 public Format(WaveFormat format, uint MpeBitRate)
 {
   lhv1 = new LHV1(format, MpeBitRate);
 }
Esempio n. 30
0
 public static extern int waveOutOpen(out IntPtr hWaveOut, int uDeviceID, WaveFormat lpFormat, WaveDelegate dwCallback, int dwInstance, int dwFlags);
Esempio n. 31
0
 public Mp3WriterConfig(WaveFormat InFormat, uint outputBitRate)
     : this(InFormat, new Lame.BE_CONFIG(InFormat, outputBitRate))
 {
 }
Esempio n. 32
0
 public Mp3WriterConfig(WaveFormat InFormat)
   :this(InFormat, new Lame.BE_CONFIG(InFormat))
 {
 }
Esempio n. 33
0
 public Mp3WriterConfig(WaveFormat InFormat, Lame.BE_CONFIG beconfig)
   :base(InFormat)
 {
   m_BeConfig = beconfig;
 }