static void DoListDevices(SoundIO api)
{
Console.WriteLine("Inputs");
for (int i = 0; i < api.InputDeviceCount; i++)
{
PrintDevice(api.GetInputDevice(i));
}
Console.WriteLine("Outputs");
for (int i = 0; i < api.OutputDeviceCount; i++)
{
PrintDevice(api.GetInputDevice(i));
}
}
public SoundioInput(SoundIOBackend?backend = null, TimeSpan?bufferDuration = null)
{
_bufferDuration = bufferDuration ?? TimeSpan.FromSeconds(30);
if (backend.HasValue)
{
_api.ConnectBackend(backend.Value);
}
else
{
_api.Connect();
}
_api.FlushEvents();
for (int i = 0; _api.InputDeviceCount > i; i++)
{
var device = _api.GetInputDevice(i);
if (i == _api.DefaultInputDeviceIndex)
{
DefaultDevice = device;
}
Devices.Add(device);
}
}
static int ListDevices(SoundIO soundIo)
{
int outputCount = soundIo.GetOutputDeviceCount();
int inputCount = soundIo.GetInputDeviceCount();
int defaultOutput = soundIo.GetDefaultOutputDeviceIndex();
int defaultInput = soundIo.GetDefaultInputDeviceIndex();
Console.WriteLine("--------Input Devices--------");
for (int i = 0; i < inputCount; i++)
{
SoundIODevice device = soundIo.GetInputDevice(i);
PrintDevice(device, defaultInput == i);
device.Release();
}
Console.WriteLine("\n--------Output Devices--------\n");
for (int i = 0; i < outputCount; i++)
{
SoundIODevice device = soundIo.GetOutputDevice(i);
PrintDevice(device, defaultOutput == i);
device.Release();
}
Console.WriteLine("\n{0} devices found.", inputCount + outputCount);
return(0);
}
public void Devices()
{
var api = new SoundIO();
api.Connect();
try {
api.FlushEvents();
Assert.IsTrue(api.DefaultInputDeviceIndex >= -1, "default input device index");
Assert.IsTrue(api.DefaultOutputDeviceIndex >= -1, "default output device index");
for (int i = 0; i < api.OutputDeviceCount; i++)
{
var dev = api.GetOutputDevice(i);
}
for (int i = 0; i < api.InputDeviceCount; i++)
{
var dev = api.GetInputDevice(i);
}
} finally {
api.Disconnect();
}
}
public void Properties()
{
var api = new SoundIO();
api.Connect();
try {
api.FlushEvents();
var dev = api.GetInputDevice(api.DefaultInputDeviceIndex);
using (var stream = dev.CreateInStream()) {
foreach (var p in typeof(SoundIOInStream).GetProperties())
{
try {
p.GetValue(stream);
} catch (Exception ex) {
Assert.Fail("Failed to get property " + p + " : " + ex);
}
}
}
} finally {
api.Disconnect();
api.Dispose();
}
}
public static int Main(string [] args)
{
string device_id = null;
string backend_name = null;
bool raw = false;
string outfile = null;
foreach (var arg in args)
{
switch (arg)
{
case "--raw":
raw = true;
continue;
default:
if (arg.StartsWith("--backend:"))
{
backend_name = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("--device:"))
{
device_id = arg.Substring(arg.IndexOf(':') + 1);
}
else
{
outfile = arg;
}
continue;
}
}
var api = new SoundIO();
var backend = backend_name == null ? SoundIOBackend.None : (SoundIOBackend)Enum.Parse(typeof(SoundIOBackend), backend_name);
if (backend == SoundIOBackend.None)
{
api.Connect();
}
else
{
api.ConnectBackend(backend);
}
Console.WriteLine("backend: " + api.CurrentBackend);
api.FlushEvents();
var device = device_id == null?api.GetInputDevice(api.DefaultInputDeviceIndex) :
Enumerable.Range(0, api.InputDeviceCount)
.Select(i => api.GetInputDevice(i))
.FirstOrDefault(d => d.Id == device_id && d.IsRaw == raw);
if (device == null)
{
Console.Error.WriteLine("device " + device_id + " not found.");
return(1);
}
Console.WriteLine("device: " + device.Name);
if (device.ProbeError != 0)
{
Console.Error.WriteLine("Cannot probe device " + device_id + ".");
return(1);
}
var sample_rate = prioritized_sample_rates.First(sr => device.SupportsSampleRate(sr));
var fmt = prioritized_formats.First(f => device.SupportsFormat(f));
var instream = device.CreateInStream();
instream.Format = fmt;
instream.SampleRate = sample_rate;
instream.ReadCallback = (fmin, fmax) => read_callback(instream, fmin, fmax);
instream.OverflowCallback = () => overflow_callback(instream);
instream.Open();
const int ring_buffer_duration_seconds = 30;
int capacity = (int)(ring_buffer_duration_seconds * instream.SampleRate * instream.BytesPerFrame);
ring_buffer = api.CreateRingBuffer(capacity);
var buf = ring_buffer.WritePointer;
instream.Start();
Console.WriteLine("Type CTRL+C to quit by killing process...");
using (var fs = File.OpenWrite(outfile)) {
var arr = new byte [capacity];
unsafe
{
fixed(void *arrptr = arr)
{
for (; ;)
{
api.FlushEvents();
Thread.Sleep(1000);
int fill_bytes = ring_buffer.FillCount;
var read_buf = ring_buffer.ReadPointer;
Buffer.MemoryCopy((void *)read_buf, arrptr, fill_bytes, fill_bytes);
fs.Write(arr, 0, fill_bytes);
ring_buffer.AdvanceReadPointer(fill_bytes);
}
}
}
}
instream.Dispose();
device.RemoveReference();
api.Dispose();
return(0);
}
public static int Main(string [] args)
{
string in_device_id = null, out_device_id = null;
string backend_name = null;
bool in_raw = false, out_raw = false;
double microphone_latency = 0.2; // seconds
foreach (var arg in args)
{
switch (arg)
{
case "--in_raw":
in_raw = true;
continue;
case "--out_raw":
out_raw = true;
continue;
default:
if (arg.StartsWith("--backend:"))
{
backend_name = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("--in-device:"))
{
in_device_id = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("--out-device:"))
{
out_device_id = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("--latency:"))
{
microphone_latency = double.Parse(arg.Substring(arg.IndexOf(':') + 1));
}
continue;
}
}
var api = new SoundIO();
var backend = backend_name == null ? SoundIOBackend.None : (SoundIOBackend)Enum.Parse(typeof(SoundIOBackend), backend_name);
if (backend == SoundIOBackend.None)
{
api.Connect();
}
else
{
api.ConnectBackend(backend);
}
Console.WriteLine("backend: " + api.CurrentBackend);
api.FlushEvents();
var in_device = in_device_id == null?api.GetInputDevice(api.DefaultInputDeviceIndex) :
Enumerable.Range(0, api.InputDeviceCount)
.Select(i => api.GetInputDevice(i))
.FirstOrDefault(d => d.Id == in_device_id && d.IsRaw == in_raw);
if (in_device == null)
{
Console.Error.WriteLine("Input device " + in_device_id + " not found.");
return(1);
}
Console.WriteLine("input device: " + in_device.Name);
if (in_device.ProbeError != 0)
{
Console.Error.WriteLine("Cannot probe input device " + in_device_id + ".");
return(1);
}
var out_device = out_device_id == null?api.GetOutputDevice(api.DefaultOutputDeviceIndex) :
Enumerable.Range(0, api.OutputDeviceCount)
.Select(i => api.GetOutputDevice(i))
.FirstOrDefault(d => d.Id == out_device_id && d.IsRaw == out_raw);
if (out_device == null)
{
Console.Error.WriteLine("Output device " + out_device_id + " not found.");
return(1);
}
Console.WriteLine("output device: " + out_device.Name);
if (out_device.ProbeError != 0)
{
Console.Error.WriteLine("Cannot probe output device " + out_device_id + ".");
return(1);
}
out_device.SortDeviceChannelLayouts();
var layout = SoundIODevice.BestMatchingChannelLayout(out_device, in_device);
if (layout.IsNull)
{
throw new InvalidOperationException("channel layouts not compatible"); // panic()
}
var sample_rate = prioritized_sample_rates.FirstOrDefault(sr => in_device.SupportsSampleRate(sr) && out_device.SupportsSampleRate(sr));
if (sample_rate == default(int))
{
throw new InvalidOperationException("incompatible sample rates"); // panic()
}
var fmt = prioritized_formats.FirstOrDefault(f => in_device.SupportsFormat(f) && out_device.SupportsFormat(f));
if (fmt == default(SoundIOFormat))
{
throw new InvalidOperationException("incompatible sample formats"); // panic()
}
var instream = in_device.CreateInStream();
instream.Format = fmt;
instream.SampleRate = sample_rate;
instream.Layout = layout;
instream.SoftwareLatency = microphone_latency;
instream.ReadCallback = (fmin, fmax) => read_callback(instream, fmin, fmax);
instream.Open();
var outstream = out_device.CreateOutStream();
outstream.Format = fmt;
outstream.SampleRate = sample_rate;
outstream.Layout = layout;
outstream.SoftwareLatency = microphone_latency;
outstream.WriteCallback = (fmin, fmax) => write_callback(outstream, fmin, fmax);
outstream.UnderflowCallback = () => underflow_callback(outstream);
outstream.Open();
int capacity = (int)(microphone_latency * 2 * instream.SampleRate * instream.BytesPerFrame);
ring_buffer = api.CreateRingBuffer(capacity);
var buf = ring_buffer.WritePointer;
int fill_count = (int)(microphone_latency * outstream.SampleRate * outstream.BytesPerFrame);
// FIXME: there should be more efficient way for memset()
for (int i = 0; i < fill_count; i++)
{
Marshal.WriteByte(buf, i, 0);
}
ring_buffer.AdvanceWritePointer(fill_count);
instream.Start();
outstream.Start();
for (;;)
{
api.WaitEvents();
}
outstream.Dispose();
instream.Dispose();
in_device.RemoveReference();
out_device.RemoveReference();
api.Dispose();
return(0);
}
