/// <summary>
/// stops streaming from specified configured device
/// </summary>
public void Stop()
{
object error;
NativeMethods.rs2_stop(Handle, out error);
m_callback = null;
m_queue = null;
}
/// <summary>
/// start streaming from specified configured sensor of specific stream to frame queue
/// </summary>
/// <param name="queue">frame-queue to store new frames into</param>
// TODO: overload with state object and Action<Frame, object> callback to avoid allocations
public void Start(FrameQueue queue)
{
object error;
NativeMethods.rs2_start_queue(Handle, queue.Handle, out error);
m_queue = queue;
m_callback = null;
}
public void Start(FrameCallback cb)
{
object error;
frame_callback cb2 = (IntPtr f, IntPtr u) =>
{
using (var frame = new Frame(f))
cb(frame);
};
m_callback = cb2;
m_queue = null;
NativeMethods.rs2_start(m_instance, cb2, IntPtr.Zero, out error);
}
public void Start <T>(Action <T> cb) where T : Frame
{
object error;
frame_callback cb2 = (IntPtr f, IntPtr u) =>
{
using (var frame = Frame.Create <T>(f))
cb(frame);
};
m_callback = cb2;
m_queue = null;
NativeMethods.rs2_start(m_instance, cb2, IntPtr.Zero, out error);
}
public PipelineProfile Start(Config cfg, FrameCallback cb)
{
object error;
frame_callback cb2 = (IntPtr f, IntPtr u) =>
{
using (var frame = new Frame(f))
cb(frame);
};
m_callback = cb2;
var res = NativeMethods.rs2_pipeline_start_with_config_and_callback(m_instance.Handle, cfg.m_instance.Handle, cb2, IntPtr.Zero, out error);
var prof = new PipelineProfile(res);
return(prof);
}
/// <summary>start streaming from specified configured sensor</summary>
/// <param name="cb">delegate to register as per-frame callback</param>
// TODO: overload with state object and Action<Frame, object> callback to avoid allocations
public void Start(FrameCallback cb)
{
object error;
frame_callback cb2 = (IntPtr f, IntPtr u) =>
{
using (var frame = Frame.Create(f))
{
cb(frame);
}
};
m_callback = cb2;
m_queue = null;
NativeMethods.rs2_start(Handle, cb2, IntPtr.Zero, out error);
}
public void Start(FrameCallback cb)
{
object error;
frame_callback cb2 = (IntPtr f, IntPtr u) =>
{
//!TODO: check whether or not frame should be diposed here... I've got 2 concerns here:
// 1. Best practice says that since the user's callback isn't the owner, frame should be diposed here...
// 2. Users might need the frame for longer, but then they could clone it
//cb(new Frame(f));
using (var frame = new Frame(f))
cb(frame);
};
NativeMethods.rs2_start(m_instance, cb2, IntPtr.Zero, out error);
}
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
// TODO: dispose managed state (managed objects).
m_callback = null;
}
// TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
// TODO: set large fields to null.
Release();
disposedValue = true;
}
}
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
// TODO: dispose managed state (managed objects).
m_callback = null;
}
// TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
// TODO: set large fields to null.
NativeMethods.rs2_delete_sensor(m_instance);
disposedValue = true;
}
}
/// <summary>
/// Start the pipeline streaming with its default configuration.
/// <para>
/// The pipeline captures samples from the device, and delivers them to the through the provided frame callback.
/// </para>
/// </summary>
/// <remarks>
/// Starting the pipeline is possible only when it is not started. If the pipeline was started, an exception is raised.
/// When starting the pipeline with a callback both <see cref="WaitForFrames"/> or <see cref="PollForFrames"/> will throw exception.
/// </remarks>
/// <param name="cb">Delegate to register as per-frame callback</param>
/// <returns>The actual pipeline device and streams profile, which was successfully configured to the streaming device.</returns>
// TODO: overload with state object and Action<Frame, object> callback to avoid allocations
public PipelineProfile Start(FrameCallback cb)
{
object error;
frame_callback cb2 = (IntPtr f, IntPtr u) =>
{
using (var frame = Frame.Create(f))
{
cb(frame);
}
};
m_callback = cb2;
var res = NativeMethods.rs2_pipeline_start_with_callback(Handle, cb2, IntPtr.Zero, out error);
var prof = new PipelineProfile(res);
return(prof);
}
internal static extern void rs2_set_devices_changed_callback(IntPtr context, [MarshalAs(UnmanagedType.FunctionPtr)] frame_callback callback, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(Helpers.ErrorMarshaler))] out object error);
internal static extern void rs2_set_notifications_callback(IntPtr sensor, [MarshalAs(UnmanagedType.FunctionPtr)] frame_callback on_notification, IntPtr user, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(Helpers.ErrorMarshaler))] out object error);
