Esempio n. 1
0
 public override object ConvertTo(ITypeDescriptorContext context,
                                  CultureInfo culture, object value, Type destinationType)
 {
     if (destinationType == typeof(string))
     {
         SoundFormat soundFormat = (SoundFormat)value;
         return(string.Format(
                    culture,
                    "{0}, {1:.000} {2}{3}, {4:.000} {5}{6}, {7} {8}, {9}, {10} {11}",
                    soundFormat.Tag,
                    (float)(soundFormat.AverageBytesPerSecond * 8) / bytesPow,
                    kilo,
                    bps,
                    (float)soundFormat.SamplesPerSecond / hertzPow,
                    kilo,
                    hz,
                    soundFormat.BitsPerSample,
                    bit,
                    soundFormat.Channels == 1 ? mono : stereo,
                    soundFormat.BlockAlign,
                    block
                    ));
     }
     return(base.ConvertTo(context, culture, value, destinationType));
 }
Esempio n. 2
0
        private bool EnumDeviceFormatsCallback(IntPtr lpws, string lpDevice, IntPtr pwfx)
        {
            SoundFormat soundFormat = new SoundFormat(pwfx);

            callbackDeviceFormats.Add(soundFormat);
            return(true);
        }
Esempio n. 3
0
        public SoundFormat Clone()
        {
            SoundFormat copy = (SoundFormat)this.MemberwiseClone();

            if (this.extra != null)
            {
                copy.extra = (byte[])this.extra.Clone();
            }
            return(copy);
        }
Esempio n. 4
0
        public static SoundFormat SuggestFormat(string deviceId, SoundFormatTag?tag, int?samplesPerSecond,
                                                int?channels)
        {
            if (string.IsNullOrEmpty(deviceId))
            {
                throw new ArgumentNullException("deviceId");
            }
            if (tag == null)
            {
                tag = preferredFormat.Tag;
            }
            if (samplesPerSecond == null)
            {
                samplesPerSecond = preferredFormat.SamplesPerSecond;
            }
            if (channels == null)
            {
                channels = preferredFormat.Channels;
            }
            SoundFormat[] availableFormats = GetFormats(deviceId, true);
            // Find the closest format to the specified paramters
            // Priorities: 1) Tag 2) Sample Rate 3) Channels
            SoundFormat suggestedFormat     = null;
            float       suggestedMatchValue = int.MinValue;

            foreach (SoundFormat format in availableFormats)
            {
                float matchValue = 0;
                if (tag != null && format.Tag == tag.Value)
                {
                    matchValue += 4.0f;
                }
                if (samplesPerSecond != null)
                {
                    float diffRatio = 2.0f - (Math.Abs(format.SamplesPerSecond - samplesPerSecond.Value)
                                              / (samplesPerSecond.Value + format.SamplesPerSecond + 1.0f));
                    matchValue += diffRatio;
                }
                if (channels != null && channels.Value == format.Channels)
                {
                    matchValue += 1.0f;
                }
                if (matchValue > suggestedMatchValue)
                {
                    suggestedFormat     = format;
                    suggestedMatchValue = matchValue;
                }
            }
            return(suggestedFormat);
        }
Esempio n. 5
0
        public override bool Equals(object obj)
        {
            SoundFormat soundFormat = obj as SoundFormat;

            if (soundFormat == null)
            {
                return(false);
            }
            return(soundFormat.avgBytesPerSecond.Equals(this.avgBytesPerSecond) &&
                   soundFormat.bitsPerSample.Equals(this.bitsPerSample) &&
                   soundFormat.blockAlign.Equals(this.blockAlign) &&
                   soundFormat.channels.Equals(this.channels) &&
                   soundFormat.samplesPerSecond.Equals(this.samplesPerSecond));
        }
Esempio n. 6
0
        public AcmEncoder GetEncoder()
        {
            bool        encoderNeeded;
            SoundFormat inputFormat = GetInputFormat(out encoderNeeded);

            if (!encoderNeeded)
            {
                return(null);
            }
            AcmEncoder encoder = new AcmEncoder();

            encoder.InputFormat  = inputFormat;
            encoder.OutputFormat = this.format;
            return(encoder);
        }
Esempio n. 7
0
        public static SoundFormat[] WaveFormatToSoundFormats(MMInterop.WaveFormat formats)
        {
            List <SoundFormat> soundFormats = new List <SoundFormat>();
            Array allValues = Enum.GetValues(typeof(MMInterop.WaveFormat));

            foreach (var value in allValues)
            {
                MMInterop.WaveFormat vformat = (MMInterop.WaveFormat)value;
                if ((int)value == 0) // WAVE_INVALID_FORMAT
                {
                    continue;
                }
                if ((formats & vformat) == vformat)
                {
                    SoundFormat format = WaveFormatToSoundFormat(vformat);
                    soundFormats.Add(format);
                }
            }
            return(soundFormats.ToArray());
        }
Esempio n. 8
0
        private SoundFormat GetInputFormat(out bool encoderNeeded)
        {
            int nMaxAvgBytesPerSec = 0;

            // Get device formats
            SoundFormat[]      deviceFormats    = this.wrapper.GetDeviceFormats(deviceId);
            List <SoundFormat> deviceFormatList = new List <SoundFormat>(deviceFormats);
            SoundFormat        inputFormat      = null;

            if (this.format == null)
            {
                // If format is not specified, find the format with maximum average bytes per second
                foreach (SoundFormat deviceFormat in deviceFormatList)
                {
                    if (inputFormat == null || nMaxAvgBytesPerSec < deviceFormat.AverageBytesPerSecond)
                    {
                        inputFormat        = deviceFormat;
                        nMaxAvgBytesPerSec = deviceFormat.AverageBytesPerSecond;
                    }
                }
                if (inputFormat == null)
                {
                    // This happens only if device has not formats
                    throw new InvalidOperationException("Cannot find an appropriate input format.");
                }
                encoderNeeded = false;
                return(inputFormat);
            }

            // Check if device supports the format
            if (deviceFormatList.Contains(this.format))
            {
                encoderNeeded = false;
                return(this.format);
            }

            // Get available input formats for convertion
            SoundFormat[] availableInputs = convertionMap.GetInputs(this.format);
            if (availableInputs.Length == 0)
            {
                // Get convertion map again
                // We currenty use PCM format for output.
                convertionMap.Add(AcmEncoder.GetConvertionMap(deviceFormatList.ToArray(), preferredFormat.Tag));
                // Get available input formats for convertion
                availableInputs = convertionMap.GetInputs(this.format);
                if (availableInputs.Length == 0)
                {
                    throw new InvalidOperationException("Cannot find an appropriate input format.");
                }
            }

            // Find the input format that device supports and has
            // maximum average bytes per second
            foreach (SoundFormat input in availableInputs)
            {
                if (deviceFormatList.Contains(input))
                {
                    if (nMaxAvgBytesPerSec < input.AverageBytesPerSecond &&
                        (inputFormat == null ||
                         input.AverageBytesPerSecond == (input.BitsPerSample / 8) * input.Channels * input.SamplesPerSecond))
                    {
                        inputFormat        = input;
                        nMaxAvgBytesPerSec = (int)input.AverageBytesPerSecond;
                    }
                }
            }
            if (inputFormat == null)
            {
                throw new InvalidOperationException("Cannot find an appropriate input format.");
            }
            encoderNeeded = true;
            return(inputFormat);
        }
Esempio n. 9
0
 private static int SoundFormatComparer(SoundFormat a, SoundFormat b)
 {
     return a.AverageBytesPerSecond.CompareTo(b.AverageBytesPerSecond);
 }
Esempio n. 10
0
            public IntPtr MarshalManagedToNative(object ManagedObj)
            {
                SoundFormat wfx = (SoundFormat)ManagedObj;

                return(wfx.ToPtr());
            }
Esempio n. 11
0
 private bool EnumDeviceFormatsCallback(IntPtr lpws, string lpDevice, IntPtr pwfx)
 {
     SoundFormat soundFormat = new SoundFormat(pwfx);
      callbackDeviceFormats.Add(soundFormat);
      return true;
 }
Esempio n. 12
0
 private void SetupAudio(SoundFormat audioFormat, AcmEncoder audioEncoder)
 {
     IntPtr pwfx = audioFormat.ToPtr();
      try {
     Avi32Interop.AVISTREAMINFO asi = new Avi32Interop.AVISTREAMINFO();
     asi.fccType = Avi32Interop.streamtypeAUDIO;
     asi.dwScale = audioFormat.BlockAlign;
     asi.dwRate = audioFormat.AverageBytesPerSecond;
     asi.dwStart = 0;
     asi.dwLength = -1;
     asi.dwInitialFrames = 0;
     asi.dwSuggestedBufferSize = 0;
     asi.dwQuality = -1;
     asi.dwSampleSize = audioFormat.BlockAlign;
     int hr = Avi32Interop.AVIFileCreateStream(this.pAviFile, out this.pAudioStream, ref asi);
     if (hr != 0) {
        throw new AviException("AVIStreamSetFormat", hr);
     }
     hr = Avi32Interop.AVIStreamSetFormat(this.pAudioStream, 0, pwfx, audioFormat.ToalSize);
     if (hr != 0) {
        throw new AviException("AVIStreamSetFormat", hr);
     }
     if (audioEncoder != null) {
        audioEncoder.Open();
     }
     this.audioFormat = audioFormat;
     this.audioEncoder = audioEncoder;
      }
      finally {
     Marshal.FreeHGlobal(pwfx);
      }
 }
Esempio n. 13
0
 public void Open(string fileName, DisplayFormat videoFormat, int fps, VideoCompressor compressor, 
                SoundFormat audioFormat, AcmEncoder audioEncoder)
 {
     if (this.opened) {
     throw new InvalidOperationException();
      }
      if (string.IsNullOrEmpty(fileName)) {
     throw new ArgumentNullException("fileName");
      }
      this.video = videoFormat != null;
      this.audio = audioFormat != null;
      if (!this.audio && !this.video) {
     // There is nothing to do!
     throw new InvalidOperationException();
      }
      // Open AVI File
      int hr = Avi32Interop.AVIFileOpen(out this.pAviFile, fileName, Avi32Interop.OF_CREATE, IntPtr.Zero);
      if (hr != 0) {
     throw new AviException("AVIFileOpen", hr);
      }
      try {
     if (this.video) {
       this.SetupVideo(videoFormat, compressor, fps);
     }
     if (this.audio) {
        this.SetupAudio(audioFormat, audioEncoder);
     }
     this.opened = true;
      }
      finally {
     if (!this.opened) {
        this.Close();
     }
      }
 }