public void StartIsoStreaming(ref StreamControl control, FrameCallback callback) { var error = NativeMethods.uvc_start_iso_streaming(handle, ref control, callback, IntPtr.Zero); UvcException.ThrowExceptionForUvcError(error); cb = callback; }
/// <summary> /// /// </summary> /// <param name="frameOrLabel"></param> /// <param name="callback"></param> /// <returns></returns> public bool addFrameScript(object frameOrLabel, FrameCallback callback) { if (frameCallbacks == null) { return(false); } if (m_MovieClipInfo == null) { return(false); } if (m_SymbolName == null) { return(false); } int num = 0; if (frameOrLabel is string) { num = getFrameLabel((string)frameOrLabel) - 1; } else if (frameOrLabel is int) { num = ((int)frameOrLabel) - 1; } if ((num < 0) || (num >= m_MovieClipInfo.frames.Count)) { return(false); } if (frameCallbacks.ContainsKey(num)) { return(false); } frameCallbacks[num] = callback; return(true); }
internal _FrameCallbackEntry(FrameCallback callback, bool rescheduling = false) { this.callback = callback; D.assert(() => { if (rescheduling) { D.assert(() => { if (debugCurrentCallbackStack == null) { throw new UIWidgetsError( new List<DiagnosticsNode> { new ErrorSummary( "scheduleFrameCallback called with rescheduling true, but no callback is in scope."), new ErrorDescription( "The \"rescheduling\" argument should only be set to true if the " + "callback is being reregistered from within the callback itself, " + "and only then if the callback itself is entirely synchronous."), new ErrorHint("If this is the initial registration of the callback, or if the " + "callback is asynchronous, then do not use the \"rescheduling\" " + "argument.") }); } return true; }); debugStack = debugCurrentCallbackStack; } else { debugStack = StackTraceUtility.ExtractStackTrace(); } return true; }); }
void _invokeFrameCallback(FrameCallback callback, TimeSpan timeStamp, StackTrace callbackStack = null) { D.assert(callback != null); D.assert(_FrameCallbackEntry.debugCurrentCallbackStack == null); D.assert(() => { _FrameCallbackEntry.debugCurrentCallbackStack = callbackStack; return(true); }); try { callback(timeStamp); } catch (Exception ex) { UIWidgetsError.reportError(new UIWidgetsErrorDetails( exception: ex, library: "scheduler library", context: "during a scheduler callback", informationCollector: callbackStack == null ? (InformationCollector)null : information => { information.AppendLine( "\nThis exception was thrown in the context of a scheduler callback. " + "When the scheduler callback was _registered_ (as opposed to when the " + "exception was thrown), this was the stack:" ); UIWidgetsError.defaultStackFilter(callbackStack.ToString().TrimEnd().Split('\n')) .Each((line) => information.AppendLine(line)); } )); } D.assert(() => { _FrameCallbackEntry.debugCurrentCallbackStack = null; return(true); }); }
public int scheduleFrameCallback(FrameCallback callback, bool rescheduling = false) { scheduleFrame(); _nextFrameCallbackId += 1; _transientCallbacks[key: _nextFrameCallbackId] = new _FrameCallbackEntry(callback: callback, rescheduling: rescheduling); return _nextFrameCallbackId; }
//[HandleProcessCorruptedStateExceptions] public void Close() { try { m_bRunning = false; int nTry = 200; while (true && m_ThreadCamera != null && m_bException == false) { nTry--; System.Windows.Forms.Application.DoEvents(); bool bret = m_ThreadCamera == null || m_ThreadCamera.Join(10); if (bret || nTry <= 0) { break; } } m_cbFrame = null; m_ThreadCamera = null; //make sure the camera is closed if (m_nOpenCount > 0) { m_nOpenCount = 0; CloseCamera(m_nID); } } catch (System.Exception ex) { m_bException = true; ProcessException(m_nID, FUNC_CLOSE, ex.ToString()); } m_cbError = null; }
internal _FrameCallbackEntry(FrameCallback callback, bool rescheduling = false) { this.callback = callback; D.assert(() => { if (rescheduling) { D.assert(() => { if (debugCurrentCallbackStack == null) { throw new UIWidgetsError( "scheduleFrameCallback called with rescheduling true, but no callback is in scope.\n" + "The \"rescheduling\" argument should only be set to true if the " + "callback is being reregistered from within the callback itself, " + "and only then if the callback itself is entirely synchronous. " + "If this is the initial registration of the callback, or if the " + "callback is asynchronous, then do not use the \"rescheduling\" " + "argument."); } return(true); }); this.debugStack = debugCurrentCallbackStack; } else { this.debugStack = new StackTrace(2, true); } return(true); }); }
//[HandleProcessCorruptedStateExceptions] public bool Start(FrameCallback func, int nWidht = 640, int nHeight = 480, int nFPS = 30) { try { if (m_ThreadCamera != null) { Close(); } m_bException = false; if (0 != OpenCamera(m_nID, nWidht, nHeight, nFPS)) { return(false); } m_nOpenCount++; m_cbFrame = func; ParameterizedThreadStart ParStart = new ParameterizedThreadStart(ThreadCamera); m_ThreadCamera = new Thread(ParStart); m_ThreadCamera.Start(m_nID); return(true); } catch (System.Exception ex) { m_bException = true; ProcessException(m_nID, FUNC_START, ex.ToString()); } return(false); }
public int scheduleFrameCallback(FrameCallback callback, bool rescheduling = false) { this.scheduleFrame(); this._nextFrameCallbackId += 1; this._transientCallbacks[this._nextFrameCallbackId] = new _FrameCallbackEntry(callback, rescheduling: rescheduling); return(this._nextFrameCallbackId); }
/// <summary> /// Start the processing block, delivering frames to a callback /// </summary> /// <param name="cb"></param> public void Start(FrameCallback cb) { frameCallbackHandle = GCHandle.Alloc(cb, GCHandleType.Normal); IntPtr cbPtr = GCHandle.ToIntPtr(frameCallbackHandle); object error; NativeMethods.rs2_start_processing_fptr(m_instance.Handle, m_frameCallback, cbPtr, out error); }
public CameraWrapper(int nID, ErrorCallback func = null) { m_nID = nID; m_cbError = func; m_bRunning = false; m_ThreadCamera = null; m_cbFrame = null; m_nOpenCount = 0; }
public void removeFrameCallback(FrameCallback callbackWrapper) { if (IS_JELLYBEAN_OR_HIGHER) { choreographerRemoveFrameCallback(callbackWrapper.getFrameCallback()); } else { mHandler.RemoveCallbacks(callbackWrapper.getRunnable()); } }
public void postFrameCallbackDelayed(FrameCallback callbackWrapper, long delayMillis) { if (IS_JELLYBEAN_OR_HIGHER) { choreographerPostFrameCallbackDelayed(callbackWrapper.getFrameCallback(), delayMillis); } else { mHandler.PostDelayed(callbackWrapper.getRunnable(), delayMillis + ONE_FRAME_MILLIS); } }
public void PostFrameCallback(FrameCallback callbackWrapper) { if (IS_JELLYBEAN_OR_HIGHER) { choreographerPostFrameCallback(callbackWrapper.getFrameCallback()); } else { mHandler.PostDelayed(callbackWrapper.getRunnable(), 0); } }
public Device(int id, PacketPipeline pipeline = PacketPipeline.Default) { handle = freenect2_device_create(Context, id, pipeline); if (handle == IntPtr.Zero) { throw new Exception("Could not create Kinect device"); } ++contextRefCount; frameCallback = new FrameCallback(HandleFrame); freenect2_device_set_frame_callback(handle, frameCallback); }
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 Device(int id, PacketPipeline pipeline = PacketPipeline.Default) { handle = freenect2_device_create(Context, id, pipeline); if (handle == IntPtr.Zero) { throw new Exception("Could not create Kinect device"); } ++contextRefCount; frameCallback = new FrameCallback(HandleFrame); freenect2_device_set_frame_callback(handle, frameCallback); }
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); }
/// <summary> /// Sets up a frame callback that is called immediately when an image is available, /// with no synchronization logic applied. /// </summary> /// <param name="onFrame">The function to be called whenever a new image is available.</param> public void Start(FrameCallback onFrame) { if (onFrame == null) { throw new ArgumentNullException(nameof(onFrame)); } frameCallback = (frame, user) => { var frameHandle = new FrameHandle(frame); onFrame(new Frame(frameHandle, this)); }; NativeMethods.rs2_start(handle, frameCallback, IntPtr.Zero, out IntPtr error); NativeHelper.ThrowExceptionForRsError(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); }
void _invokeFrameCallback(FrameCallback callback, TimeSpan timeStamp, string callbackStack = null) { D.assert(callback != null); D.assert(_FrameCallbackEntry.debugCurrentCallbackStack == null); D.assert(() => { _FrameCallbackEntry.debugCurrentCallbackStack = callbackStack; return(true); }); try { callback(timeStamp: timeStamp); } catch (Exception ex) { IEnumerable <DiagnosticsNode> infoCollector() { yield return(DiagnosticsNode.message( "\nThis exception was thrown in the context of a scheduler callback. " + "When the scheduler callback was _registered_ (as opposed to when the " + "exception was thrown), this was the stack:")); var builder = new StringBuilder(); foreach (var line in UIWidgetsError.defaultStackFilter( callbackStack.TrimEnd().Split('\n'))) { builder.AppendLine(value: line); } yield return(DiagnosticsNode.message(builder.ToString())); } UIWidgetsError.reportError(new UIWidgetsErrorDetails( exception: ex, "scheduler library", new ErrorDescription("during a scheduler callback"), informationCollector: callbackStack == null ? (InformationCollector)null : infoCollector )); } D.assert(() => { _FrameCallbackEntry.debugCurrentCallbackStack = null; return(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); }
public Form1() { InitializeComponent(); int id = 0; m_dl2[id] = new DeckLinkCSCaptureApi(id); AppSettings.Instance.Load("DeckLinkDueCaptureApp.json"); this.KeyPreview = true; Control.CheckForIllegalCrossThreadCalls = false; pFrameCallback = new FrameCallback(FrameCallbackData); //m_dl2[id].SetFrameCallback(pFrameCallback); m_dl2[id].SetVideoHandle(panel1.Handle); m_dl2[id].SetWindowSize(0, 0, panel1.Width, panel1.Height); if (AppSettings.Instance.Config.EnableDownGraph > 0) { if (AppSettings.Instance.Config.EnableDownGraph == 1) { m_dl2[id].Build_H264_TransportMux_Network(AppSettings.Instance.Config.MulticastIpAddress, AppSettings.Instance.Config.MulticastPort, AppSettings.Instance.Config.NicIpAddress, AppSettings.Instance.Config.bitrate, AppSettings.Instance.Config.gopLength); } if (AppSettings.Instance.Config.EnableDownGraph == 2) { m_dl2[id].Build_H264QS_TransportMux_Network(AppSettings.Instance.Config.MulticastIpAddress, AppSettings.Instance.Config.MulticastPort, AppSettings.Instance.Config.NicIpAddress, AppSettings.Instance.Config.bitrate, AppSettings.Instance.Config.gopLength); } } int res; if ((res = m_dl2[id].StartCapture(AppSettings.Instance.Config.Device, SURFACE_ENGINE.DX9)) < 0) { MessageBox.Show("Failed to start capture: " + res); } }
public void addPersistentFrameCallback(FrameCallback callback) { _persistentCallbacks.Add(item: callback); }
public mupen64plusApi(N64 bizhawkCore, byte[] rom, VideoPluginSettings video_settings, int SaveType, int CoreType, bool DisableExpansionSlot) { // There can only be one core (otherwise breaks mupen64plus) if (AttachedCore != null) { AttachedCore.Dispose(); AttachedCore = null; } this.bizhawkCore = bizhawkCore; CoreDll = LoadLibrary("mupen64plus.dll"); if (CoreDll == IntPtr.Zero) throw new InvalidOperationException(string.Format("Failed to load mupen64plus.dll")); connectFunctionPointers(); // Start up the core m64p_error result = m64pCoreStartup(0x20001, "", "", "Core", null, "", IntPtr.Zero); // Set the savetype if needed if (DisableExpansionSlot) { IntPtr core_section = IntPtr.Zero; int disable = 1; m64pConfigOpenSection("Core", ref core_section); m64pConfigSetParameter(core_section, "DisableExtraMem", m64p_type.M64TYPE_INT, ref disable); } // Set the savetype if needed if (SaveType != 0) { IntPtr core_section = IntPtr.Zero; m64pConfigOpenSection("Core", ref core_section); m64pConfigSetParameter(core_section, "SaveType", m64p_type.M64TYPE_INT, ref SaveType); } IntPtr coreSection = IntPtr.Zero; m64pConfigOpenSection("Core", ref coreSection); m64pConfigSetParameter(coreSection, "R4300Emulator", m64p_type.M64TYPE_INT, ref CoreType); // Pass the rom to the core result = m64pCoreDoCommandByteArray(m64p_command.M64CMD_ROM_OPEN, rom.Length, rom); // Open the general video settings section in the config system IntPtr video_section = IntPtr.Zero; m64pConfigOpenSection("Video-General", ref video_section); // Set the desired width and height for mupen64plus result = m64pConfigSetParameter(video_section, "ScreenWidth", m64p_type.M64TYPE_INT, ref video_settings.Width); result = m64pConfigSetParameter(video_section, "ScreenHeight", m64p_type.M64TYPE_INT, ref video_settings.Height); set_video_parameters(video_settings); InitSaveram(); // Initialize event invoker m64pFrameCallback = new FrameCallback(FireFrameFinishedEvent); result = m64pCoreDoCommandFrameCallback(m64p_command.M64CMD_SET_FRAME_CALLBACK, 0, m64pFrameCallback); m64pVICallback = new VICallback(FireVIEvent); result = m64pCoreDoCommandVICallback(m64p_command.M64CMD_SET_VI_CALLBACK, 0, m64pVICallback); m64pRenderCallback = new RenderCallback(FireRenderEvent); result = m64pCoreDoCommandRenderCallback(m64p_command.M64CMD_SET_RENDER_CALLBACK, 0, m64pRenderCallback); // Prepare to start the emulator in a different thread m64pEmulator = new Thread(ExecuteEmulator); AttachedCore = this; }
public mupen64plusApi(N64 bizhawkCore, byte[] rom, VideoPluginSettings video_settings, int SaveType, int CoreType, bool DisableExpansionSlot) { // There can only be one core (otherwise breaks mupen64plus) if (AttachedCore != null) { AttachedCore.Dispose(); AttachedCore = null; } this.bizhawkCore = bizhawkCore; CoreDll = LoadLibrary("mupen64plus.dll"); if (CoreDll == IntPtr.Zero) { throw new InvalidOperationException(string.Format("Failed to load mupen64plus.dll")); } connectFunctionPointers(); // Start up the core m64p_error result = m64pCoreStartup(0x20001, "", "", "Core", null, "", IntPtr.Zero); // Open the core settings section in the config system IntPtr core_section = IntPtr.Zero; m64pConfigOpenSection("Core", ref core_section); // Set the savetype if needed if (DisableExpansionSlot) { int disable = 1; m64pConfigSetParameter(core_section, "DisableExtraMem", m64p_type.M64TYPE_INT, ref disable); } // Set the savetype if needed if (SaveType != 0) { m64pConfigSetParameter(core_section, "SaveType", m64p_type.M64TYPE_INT, ref SaveType); } m64pConfigSetParameter(core_section, "R4300Emulator", m64p_type.M64TYPE_INT, ref CoreType); // Pass the rom to the core result = m64pCoreDoCommandByteArray(m64p_command.M64CMD_ROM_OPEN, rom.Length, rom); // Open the general video settings section in the config system IntPtr video_section = IntPtr.Zero; m64pConfigOpenSection("Video-General", ref video_section); // Set the desired width and height for mupen64plus result = m64pConfigSetParameter(video_section, "ScreenWidth", m64p_type.M64TYPE_INT, ref video_settings.Width); result = m64pConfigSetParameter(video_section, "ScreenHeight", m64p_type.M64TYPE_INT, ref video_settings.Height); set_video_parameters(video_settings); InitSaveram(); // Initialize event invoker m64pFrameCallback = new FrameCallback(FireFrameFinishedEvent); result = m64pCoreDoCommandFrameCallback(m64p_command.M64CMD_SET_FRAME_CALLBACK, 0, m64pFrameCallback); m64pVICallback = new VICallback(FireVIEvent); result = m64pCoreDoCommandVICallback(m64p_command.M64CMD_SET_VI_CALLBACK, 0, m64pVICallback); m64pRenderCallback = new RenderCallback(FireRenderEvent); result = m64pCoreDoCommandRenderCallback(m64p_command.M64CMD_SET_RENDER_CALLBACK, 0, m64pRenderCallback); // Prepare to start the emulator in a different thread m64pEmulator = new Thread(ExecuteEmulator); AttachedCore = this; }
[DllImport("freenect2c")] private static extern void freenect2_device_set_frame_callback(IntPtr device, FrameCallback callback);
[DllImport("freenect2c")] private static extern void freenect2_device_set_frame_callback(IntPtr device, FrameCallback callback);
public void addPostFrameCallback(FrameCallback callback) { _postFrameCallbacks.Add(item: callback); }
internal static extern void rs2_start(SensorHandle sensor, FrameCallback on_frame, IntPtr user, out RsError error);
public void addPersistentFrameCallback(FrameCallback callback) { this._persistentCallbacks.Add(callback); }
public void addPostFrameCallback(FrameCallback callback) { this._postFrameCallbacks.Add(callback); }