sean-m
/
Vanara
mirror of https://github.com/dahall/Vanara.git
1
0
Fork 0
Code Issues Releases Wiki Activity
Vanara/PInvoke/Multimedia/Vfw.cap.cs

1938 lines
100 KiB
C#
Raw Blame History

#pragma warning disable IDE1006 // Naming Styles
using System;
using System.Runtime.InteropServices;
using System.Text;
using static Vanara.PInvoke.WinMm;
namespace Vanara.PInvoke
{
/// <summary>Items from the Vfw32.dll</summary>
public static partial class Vfw32
{
private const string Lib_Avicap32 = "avicap32.dll";
/// <summary>
/// <para>
/// The <c>capControlCallback</c> function is the callback function used for precision control to begin and end streaming capture.
/// The name <c>capControlCallback</c> is a placeholder for the application-supplied function name.
/// </para>
/// <para>
/// To set the callback, send the WM_CAP_SET_CALLBACK_CAPCONTROL message to the capture window or call the
/// capSetCallbackOnCapControl macro.
/// </para>
/// </summary>
/// <param name="hWnd">Handle to the capture window associated with the callback function.</param>
/// <param name="nState">
/// Current state of the capture operation. The CONTROLCALLBACK_PREROLL value is sent initially to enable prerolling of the video
/// sources and to return control to the capture application at the exact moment recording is to begin. The
/// CONTROLCALLBACK_CAPTURING value is sent once per captured frame to indicate that streaming capture is in progress and to enable
/// the application to end capture.
/// </param>
/// <returns>
/// When nState is set to CONTROLCALLBACK_PREROLL, this callback function must return <c>TRUE</c> to start capture or <c>FALSE</c>
/// to abort it. When nState is set to CONTROLCALLBACK_CAPTURING, this callback function must return <c>TRUE</c> to continue capture
/// or <c>FALSE</c> to end it.
/// </returns>
/// <remarks>
/// The first message sent to the callback procedure sets the nState parameter to CONTROLCALLBACK_PREROLL after allocating all
/// buffers and all other capture preparations are complete.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nc-vfw-capcontrolcallback CAPCONTROLCALLBACK Capcontrolcallback; LRESULT
// Capcontrolcallback( HWND hWnd, int nState ) {...}
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
[PInvokeData("vfw.h", MSDNShortId = "NC:vfw.CAPCONTROLCALLBACK")]
public delegate IntPtr capControlCallback(HWND hWnd, CONTROLCALLBACK nState);
/// <summary>
/// <para>
/// The <c>capErrorCallback</c> function is the error callback function used with video capture. The name <c>capErrorCallback</c> is
/// a placeholder for the application-supplied function name.
/// </para>
/// <para>
/// To set the callback, send the WM_CAP_SET_CALLBACK_ERROR message to the capture window or call the capSetCallbackOnError macro.
/// </para>
/// </summary>
/// <param name="hWnd">Handle to the capture window associated with the callback function.</param>
/// <param name="nID">Error identification number.</param>
/// <param name="lpsz">Pointer to a textual description of the returned error.</param>
/// <returns>None</returns>
/// <remarks>
/// <para>
/// A message identifier of zero indicates a new operation is starting and the callback function should clear the current error.
/// </para>
/// <para>
/// <para>Note</para>
/// <para>
/// The vfw.h header defines CAPERRORCALLBACK as an alias which automatically selects the ANSI or Unicode version of this function
/// based on the definition of the UNICODE preprocessor constant. Mixing usage of the encoding-neutral alias with code that not
/// encoding-neutral can lead to mismatches that result in compilation or runtime errors. For more information, see Conventions for
/// Function Prototypes.
/// </para>
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nc-vfw-caperrorcallbacka CAPERRORCALLBACKA Caperrorcallbacka; LRESULT
// Caperrorcallbacka( HWND hWnd, int nID, LPCSTR lpsz ) {...}
[UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Auto)]
[PInvokeData("vfw.h", MSDNShortId = "NC:vfw.CAPERRORCALLBACKA")]
public delegate IntPtr capErrorCallback(HWND hWnd, int nID, [MarshalAs(UnmanagedType.LPTStr)] string lpsz);
/// <summary>
/// <para>
/// The <c>capStatusCallback</c> function is the status callback function used with video capture. The name <c>capStatusCallback</c>
/// is a placeholder for the application-supplied function name.
/// </para>
/// <para>
/// To set the callback, send the WM_CAP_SET_CALLBACK_STATUS message to the capture window or call the capSetCallbackOnStatus macro.
/// </para>
/// </summary>
/// <param name="hWnd">Handle to the capture window associated with the callback function.</param>
/// <param name="nID">Message identification number.</param>
/// <param name="lpsz">Pointer to a textual description of the returned status.</param>
/// <returns>None</returns>
/// <remarks>
/// <para>
/// During capture operations, the first message sent to the callback function is always IDS_CAP_BEGIN and the last is always
/// IDS_CAP_END. A message identifier of zero indicates a new operation is starting and the callback function should clear the
/// current status.
/// </para>
/// <para>
/// <para>Note</para>
/// <para>
/// The vfw.h header defines CAPSTATUSCALLBACK as an alias which automatically selects the ANSI or Unicode version of this function
/// based on the definition of the UNICODE preprocessor constant. Mixing usage of the encoding-neutral alias with code that not
/// encoding-neutral can lead to mismatches that result in compilation or runtime errors. For more information, see Conventions for
/// Function Prototypes.
/// </para>
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nc-vfw-capstatuscallbacka CAPSTATUSCALLBACKA Capstatuscallbacka; LRESULT
// Capstatuscallbacka( HWND hWnd, int nID, LPCSTR lpsz ) {...}
[UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Auto)]
[PInvokeData("vfw.h", MSDNShortId = "NC:vfw.CAPSTATUSCALLBACKA")]
public delegate IntPtr capStatusCallback(HWND hWnd, int nID, [MarshalAs(UnmanagedType.LPTStr)] string lpsz);
/// <summary>
/// <para>
/// The <c>capVideoStreamCallback</c> function is the callback function used with streaming capture to optionally process a frame of
/// captured video. The name <c>capVideoStreamCallback</c> is a placeholder for the application-supplied function name.
/// </para>
/// <para>
/// To set this callback for streaming capture, send the WM_CAP_SET_CALLBACK_VIDEOSTREAM message to the capture window or call the
/// capSetCallbackOnVideoStream macro.
/// </para>
/// <para>
/// To set this callback for preview frame capture, send the WM_CAP_SET_CALLBACK_FRAME message to the capture window or call the
/// capSetCallbackOnFrame macro.
/// </para>
/// </summary>
/// <param name="hWnd">Handle to the capture window associated with the callback function.</param>
/// <param name="lpVHdr">Pointer to a VIDEOHDR structure containing information about the captured frame.</param>
/// <returns>None</returns>
/// <remarks>
/// The capture window calls a video stream callback function when a video buffer is marked done by the capture driver. When
/// capturing to disk, this will precede the disk write operation.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nc-vfw-capvideocallback CAPVIDEOCALLBACK Capvideocallback; LRESULT
// Capvideocallback( HWND hWnd, LPVIDEOHDR lpVHdr ) {...}
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
[PInvokeData("vfw.h", MSDNShortId = "NC:vfw.CAPVIDEOCALLBACK")]
public delegate IntPtr capVideoStreamCallback(HWND hWnd, in VIDEOHDR lpVHdr);
/// <summary>
/// <para>
/// The <c>capWaveStreamCallback</c> function is the callback function used with streaming capture to optionally process buffers of
/// audio data. The name <c>capWaveStreamCallback</c> is a placeholder for the application-supplied function name.
/// </para>
/// <para>
/// To set the callback, send the WM_CAP_SET_CALLBACK_WAVESTREAM message to the capture window or call the
/// capSetCallbackOnWaveStream macro.
/// </para>
/// </summary>
/// <param name="hWnd">Handle to the capture window associated with the callback function.</param>
/// <param name="lpWHdr">Pointer to a WAVEHDR structure containing information about the captured audio data.</param>
/// <returns>None</returns>
/// <remarks>
/// The capture window calls a wave stream callback function when an audio buffer is marked done by the waveform-audio driver. When
/// capturing to disk, this will precede the disk write operation.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nc-vfw-capwavecallback CAPWAVECALLBACK Capwavecallback; LRESULT
// Capwavecallback( HWND hWnd, LPWAVEHDR lpWHdr ) {...}
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
[PInvokeData("vfw.h", MSDNShortId = "NC:vfw.CAPWAVECALLBACK")]
public delegate IntPtr capWaveStreamCallback(HWND hWnd, in WAVEHDR lpWHdr);
/// <summary>
/// <para>
/// The <c>capYieldCallback</c> function is the yield callback function used with video capture. The name <c>capYieldCallback</c> is
/// a placeholder for the application-supplied function name.
/// </para>
/// <para>
/// To set the callback, send the WM_CAP_SET_CALLBACK_YIELD message to the capture window or call the capSetCallbackOnYield macro.
/// </para>
/// </summary>
/// <param name="hWnd">Handle to the capture window associated with the callback function.</param>
/// <returns>None</returns>
/// <remarks>
/// The capture window calls the yield callback function at least once for every captured video frame, but the exact rate depends on
/// the frame rate and the overhead of the capture driver and disk.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nc-vfw-capyieldcallback CAPYIELDCALLBACK Capyieldcallback; LRESULT
// Capyieldcallback( HWND hWnd ) {...}
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
[PInvokeData("vfw.h", MSDNShortId = "NC:vfw.CAPYIELDCALLBACK")]
public delegate IntPtr capYieldCallback(HWND hWnd);
/// <summary>Window messages for capture drivers.</summary>
[PInvokeData("vfw.h")]
public enum capMessage : uint
{
/// <summary>start of unicode messages</summary>
WM_CAP_START = User32.WM_USER,
/// <summary></summary>
WM_CAP_UNICODE_START = User32.WM_USER + 100,
/// <summary></summary>
WM_CAP_GET_CAPSTREAMPTR = WM_CAP_START + 1,
/// <summary></summary>
WM_CAP_SET_CALLBACK_ERRORW = WM_CAP_UNICODE_START + 2,
/// <summary></summary>
WM_CAP_SET_CALLBACK_STATUSW = WM_CAP_UNICODE_START + 3,
/// <summary></summary>
WM_CAP_SET_CALLBACK_ERRORA = WM_CAP_START + 2,
/// <summary></summary>
WM_CAP_SET_CALLBACK_STATUSA = WM_CAP_START + 3,
/// <summary></summary>
WM_CAP_SET_CALLBACK_ERROR = WM_CAP_SET_CALLBACK_ERRORW,
/// <summary></summary>
WM_CAP_SET_CALLBACK_STATUS = WM_CAP_SET_CALLBACK_STATUSW,
/// <summary></summary>
WM_CAP_SET_CALLBACK_YIELD = WM_CAP_START + 4,
/// <summary></summary>
WM_CAP_SET_CALLBACK_FRAME = WM_CAP_START + 5,
/// <summary></summary>
WM_CAP_SET_CALLBACK_VIDEOSTREAM = WM_CAP_START + 6,
/// <summary></summary>
WM_CAP_SET_CALLBACK_WAVESTREAM = WM_CAP_START + 7,
/// <summary></summary>
WM_CAP_GET_USER_DATA = WM_CAP_START + 8,
/// <summary></summary>
WM_CAP_SET_USER_DATA = WM_CAP_START + 9,
/// <summary></summary>
WM_CAP_DRIVER_CONNECT = WM_CAP_START + 10,
/// <summary></summary>
WM_CAP_DRIVER_DISCONNECT = WM_CAP_START + 11,
/// <summary></summary>
WM_CAP_DRIVER_GET_NAMEA = WM_CAP_START + 12,
/// <summary></summary>
WM_CAP_DRIVER_GET_VERSIONA = WM_CAP_START + 13,
/// <summary></summary>
WM_CAP_DRIVER_GET_NAMEW = WM_CAP_UNICODE_START + 12,
/// <summary></summary>
WM_CAP_DRIVER_GET_VERSIONW = WM_CAP_UNICODE_START + 13,
/// <summary></summary>
WM_CAP_DRIVER_GET_NAME = WM_CAP_DRIVER_GET_NAMEW,
/// <summary></summary>
WM_CAP_DRIVER_GET_VERSION = WM_CAP_DRIVER_GET_VERSIONW,
/// <summary></summary>
WM_CAP_DRIVER_GET_CAPS = WM_CAP_START + 14,
/// <summary></summary>
WM_CAP_FILE_SET_CAPTURE_FILEA = WM_CAP_START + 20,
/// <summary></summary>
WM_CAP_FILE_GET_CAPTURE_FILEA = WM_CAP_START + 21,
/// <summary></summary>
WM_CAP_FILE_SAVEASA = WM_CAP_START + 23,
/// <summary></summary>
WM_CAP_FILE_SAVEDIBA = WM_CAP_START + 25,
/// <summary></summary>
WM_CAP_FILE_SET_CAPTURE_FILEW = WM_CAP_UNICODE_START + 20,
/// <summary></summary>
WM_CAP_FILE_GET_CAPTURE_FILEW = WM_CAP_UNICODE_START + 21,
/// <summary></summary>
WM_CAP_FILE_SAVEASW = WM_CAP_UNICODE_START + 23,
/// <summary></summary>
WM_CAP_FILE_SAVEDIBW = WM_CAP_UNICODE_START + 25,
/// <summary></summary>
WM_CAP_FILE_SET_CAPTURE_FILE = WM_CAP_FILE_SET_CAPTURE_FILEW,
/// <summary></summary>
WM_CAP_FILE_GET_CAPTURE_FILE = WM_CAP_FILE_GET_CAPTURE_FILEW,
/// <summary></summary>
WM_CAP_FILE_SAVEAS = WM_CAP_FILE_SAVEASW,
/// <summary></summary>
WM_CAP_FILE_SAVEDIB = WM_CAP_FILE_SAVEDIBW,
/// <summary></summary>
WM_CAP_FILE_ALLOCATE = WM_CAP_START + 22,
/// <summary></summary>
WM_CAP_FILE_SET_INFOCHUNK = WM_CAP_START + 24,
/// <summary></summary>
WM_CAP_EDIT_COPY = WM_CAP_START + 30,
/// <summary></summary>
WM_CAP_SET_AUDIOFORMAT = WM_CAP_START + 35,
/// <summary></summary>
WM_CAP_GET_AUDIOFORMAT = WM_CAP_START + 36,
/// <summary></summary>
WM_CAP_DLG_VIDEOFORMAT = WM_CAP_START + 41,
/// <summary></summary>
WM_CAP_DLG_VIDEOSOURCE = WM_CAP_START + 42,
/// <summary></summary>
WM_CAP_DLG_VIDEODISPLAY = WM_CAP_START + 43,
/// <summary></summary>
WM_CAP_GET_VIDEOFORMAT = WM_CAP_START + 44,
/// <summary></summary>
WM_CAP_SET_VIDEOFORMAT = WM_CAP_START + 45,
/// <summary></summary>
WM_CAP_DLG_VIDEOCOMPRESSION = WM_CAP_START + 46,
/// <summary></summary>
WM_CAP_SET_PREVIEW = WM_CAP_START + 50,
/// <summary></summary>
WM_CAP_SET_OVERLAY = WM_CAP_START + 51,
/// <summary></summary>
WM_CAP_SET_PREVIEWRATE = WM_CAP_START + 52,
/// <summary></summary>
WM_CAP_SET_SCALE = WM_CAP_START + 53,
/// <summary></summary>
WM_CAP_GET_STATUS = WM_CAP_START + 54,
/// <summary></summary>
WM_CAP_SET_SCROLL = WM_CAP_START + 55,
/// <summary></summary>
WM_CAP_GRAB_FRAME = WM_CAP_START + 60,
/// <summary></summary>
WM_CAP_GRAB_FRAME_NOSTOP = WM_CAP_START + 61,
/// <summary></summary>
WM_CAP_SEQUENCE = WM_CAP_START + 62,
/// <summary></summary>
WM_CAP_SEQUENCE_NOFILE = WM_CAP_START + 63,
/// <summary></summary>
WM_CAP_SET_SEQUENCE_SETUP = WM_CAP_START + 64,
/// <summary></summary>
WM_CAP_GET_SEQUENCE_SETUP = WM_CAP_START + 65,
/// <summary></summary>
WM_CAP_SET_MCI_DEVICEA = WM_CAP_START + 66,
/// <summary></summary>
WM_CAP_GET_MCI_DEVICEA = WM_CAP_START + 67,
/// <summary></summary>
WM_CAP_SET_MCI_DEVICEW = WM_CAP_UNICODE_START + 66,
/// <summary></summary>
WM_CAP_GET_MCI_DEVICEW = WM_CAP_UNICODE_START + 67,
/// <summary></summary>
WM_CAP_SET_MCI_DEVICE = WM_CAP_SET_MCI_DEVICEW,
/// <summary></summary>
WM_CAP_GET_MCI_DEVICE = WM_CAP_GET_MCI_DEVICEW,
/// <summary></summary>
WM_CAP_STOP = WM_CAP_START + 68,
/// <summary></summary>
WM_CAP_ABORT = WM_CAP_START + 69,
/// <summary></summary>
WM_CAP_SINGLE_FRAME_OPEN = WM_CAP_START + 70,
/// <summary></summary>
WM_CAP_SINGLE_FRAME_CLOSE = WM_CAP_START + 71,
/// <summary></summary>
WM_CAP_SINGLE_FRAME = WM_CAP_START + 72,
/// <summary></summary>
WM_CAP_PAL_OPENA = WM_CAP_START + 80,
/// <summary></summary>
WM_CAP_PAL_SAVEA = WM_CAP_START + 81,
/// <summary></summary>
WM_CAP_PAL_OPENW = WM_CAP_UNICODE_START + 80,
/// <summary></summary>
WM_CAP_PAL_SAVEW = WM_CAP_UNICODE_START + 81,
/// <summary></summary>
WM_CAP_PAL_OPEN = WM_CAP_PAL_OPENW,
/// <summary></summary>
WM_CAP_PAL_SAVE = WM_CAP_PAL_SAVEW,
/// <summary></summary>
WM_CAP_PAL_PASTE = WM_CAP_START + 82,
/// <summary></summary>
WM_CAP_PAL_AUTOCREATE = WM_CAP_START + 83,
/// <summary>Following added post VFW 1.1</summary>
WM_CAP_PAL_MANUALCREATE = WM_CAP_START + 84,
/// <summary></summary>
WM_CAP_SET_CALLBACK_CAPCONTROL = WM_CAP_START + 85,
}
/// <summary>Current state of the capture operation.</summary>
[PInvokeData("vfw.h", MSDNShortId = "NC:vfw.CAPCONTROLCALLBACK")]
public enum CONTROLCALLBACK
{
/// <summary>Waiting to start capture</summary>
CONTROLCALLBACK_PREROLL = 1,
/// <summary>Now capturing</summary>
CONTROLCALLBACK_CAPTURING = 2,
}
/// <summary>Flags for VIDEOHDR.</summary>
[Flags]
public enum VHDR : uint
{
/// <summary>Done bit</summary>
VHDR_DONE = 0x00000001,
/// <summary>Set if this header has been prepared</summary>
VHDR_PREPARED = 0x00000002,
/// <summary>Reserved for driver</summary>
VHDR_INQUEUE = 0x00000004,
/// <summary>Key Frame</summary>
VHDR_KEYFRAME = 0x00000008,
}
/// <summary>
/// The <c>capCaptureAbort</c> macro stops the capture operation. You can use this macro or explictly send the WM_CAP_ABORT message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <returns>None</returns>
/// <remarks>
/// <para>The capture operation must yield to use this macro.</para>
/// <para>
/// In the case of step capture, the image data collected up to the point of the <c>capCaptureAbort</c> macro will be retained in
/// the capture file, but audio will not be captured.
/// </para>
/// <para>Use the capCaptureStop macro to halt step capture at the current position, and then capture audio.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capcaptureabort void capCaptureAbort( hwnd );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capCaptureAbort")]
public static bool capCaptureAbort(HWND hwnd) => AVICapSM(hwnd, capMessage.WM_CAP_ABORT);
/// <summary>
/// The <c>capCaptureGetSetup</c> macro retrieves the current settings of the streaming capture parameters. You can use this macro
/// or explictly send the WM_CAP_GET_SEQUENCE_SETUP message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="s">Pointer to a CAPTUREPARMS structure.</param>
/// <returns>None</returns>
/// <remarks>For information about the parameters used to control streaming capture, see the CAPTUREPARMS structure.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capcapturegetsetup void capCaptureGetSetup( hwnd, s, wSize );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capCaptureGetSetup")]
public static bool capCaptureGetSetup(HWND hwnd, out CAPTUREPARMS s) => AVICapSM(hwnd, capMessage.WM_CAP_GET_SEQUENCE_SETUP, out s) != 0;
/// <summary>
/// The <c>capCaptureSequence</c> macro initiates streaming video and audio capture to a file. You can use this macro or explicitly
/// send the WM_CAP_SEQUENCE message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <returns>None</returns>
/// <remarks>
/// <para>
/// If you want to alter the parameters controlling streaming capture, use the capCaptureSetSetup macro prior to starting the capture.
/// </para>
/// <para>
/// By default, the capture window does not allow other applications to continue running during capture. To override this, either
/// set the <c>fYield</c> member of the CAPTUREPARMS structure to <c>TRUE</c>, or install a yield callback function.
/// </para>
/// <para>
/// During streaming capture, the capture window can optionally issue notifications to your application of specific types of
/// conditions. To install callback procedures for these notifications, use the following macros:
/// </para>
/// <list type="bullet">
/// <item>
/// <term>capSetCallbackOnError</term>
/// </item>
/// <item>
/// <term>capSetCallbackOnStatus</term>
/// </item>
/// <item>
/// <term>capSetCallbackOnVideoStream</term>
/// </item>
/// <item>
/// <term>capSetCallbackOnWaveStream</term>
/// </item>
/// <item>
/// <term>capSetCallbackOnYield</term>
/// </item>
/// </list>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capcapturesequence void capCaptureSequence( hwnd );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capCaptureSequence")]
public static bool capCaptureSequence(HWND hwnd) => AVICapSM(hwnd, capMessage.WM_CAP_SEQUENCE);
/// <summary>
/// The <c>capCaptureSequenceNoFile</c> macro initiates streaming video capture without writing data to a file. You can use this
/// macro or explicitly send the WM_CAP_SEQUENCE_NOFILE message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <returns>None</returns>
/// <remarks>
/// <para>
/// This message is useful in conjunction with video stream or waveform-audio stream callback functions that let your application
/// use the video and audio data directly.
/// </para>
/// <para>
/// If you want to alter the parameters controlling streaming capture, use the capCaptureSetSetup macro prior to starting the capture.
/// </para>
/// <para>
/// By default, the capture window does not allow other applications to continue running during capture. To override this, either
/// set the <c>fYield</c> member of the CAPTUREPARMS structure to <c>TRUE</c>, or install a yield callback function.
/// </para>
/// <para>
/// During streaming capture, the capture window can optionally issue notifications to your application of specific types of
/// conditions. To install callback procedures for these notifications, use the following macros:
/// </para>
/// <list type="bullet">
/// <item>
/// <term>capSetCallbackOnError</term>
/// </item>
/// <item>
/// <term>capSetCallbackOnStatus</term>
/// </item>
/// <item>
/// <term>capSetCallbackOnVideoStream</term>
/// </item>
/// <item>
/// <term>capSetCallbackOnWaveStream</term>
/// </item>
/// <item>
/// <term>capSetCallbackOnYield</term>
/// </item>
/// </list>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capcapturesequencenofile void capCaptureSequenceNoFile( hwnd );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capCaptureSequenceNoFile")]
public static bool capCaptureSequenceNoFile(HWND hwnd) => AVICapSM(hwnd, capMessage.WM_CAP_SEQUENCE_NOFILE);
/// <summary>
/// The <c>capCaptureSetSetup</c> macro sets the configuration parameters used with streaming capture. You can use this macro or
/// explicitly send the WM_CAP_SET_SEQUENCE_SETUP message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="s">Pointer to a CAPTUREPARMS structure.</param>
/// <returns>None</returns>
/// <remarks>For information about the parameters used to control streaming capture, see the CAPTUREPARMS structure.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capcapturesetsetup void capCaptureSetSetup( hwnd, s, wSize );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capCaptureSetSetup")]
public static bool capCaptureSetSetup(HWND hwnd, in CAPTUREPARMS s) => AVICapSM(hwnd, capMessage.WM_CAP_SET_SEQUENCE_SETUP, -1, s) != 0;
/// <summary>
/// The <c>capCaptureSingleFrame</c> macro appends a single frame to a capture file that was opened using the
/// capCaptureSingleFrameOpen macro. You can use this macro or explicitly send the WM_CAP_SINGLE_FRAME message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <returns>None</returns>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capcapturesingleframe void capCaptureSingleFrame( hwnd );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capCaptureSingleFrame")]
public static bool capCaptureSingleFrame(HWND hwnd) => AVICapSM(hwnd, capMessage.WM_CAP_SINGLE_FRAME);
/// <summary>
/// The <c>capCaptureSingleFrameClose</c> macro closes the capture file opened by the capCaptureSingleFrameOpen macro. You can use
/// this macro or explicitly send the WM_CAP_SINGLE_FRAME_CLOSE message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <returns>None</returns>
/// <remarks>For information about installing callback functions, see the capSetCallbackOnError and capSetCallbackOnFrame macros.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capcapturesingleframeclose void capCaptureSingleFrameClose( hwnd );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capCaptureSingleFrameClose")]
public static bool capCaptureSingleFrameClose(HWND hwnd) => AVICapSM(hwnd, capMessage.WM_CAP_SINGLE_FRAME_CLOSE);
/// <summary>
/// The <c>capCaptureSingleFrameOpen</c> macro opens the capture file for single-frame capturing. Any previous information in the
/// capture file is overwritten. You can use this macro or explicitly send the WM_CAP_SINGLE_FRAME_OPEN message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <returns>None</returns>
/// <remarks>For information about installing callback functions, see the capSetCallbackOnError and capSetCallbackOnFrame macros.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capcapturesingleframeopen void capCaptureSingleFrameOpen( hwnd );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capCaptureSingleFrameOpen")]
public static bool capCaptureSingleFrameOpen(HWND hwnd) => AVICapSM(hwnd, capMessage.WM_CAP_SINGLE_FRAME_OPEN);
/// <summary>
/// <para>
/// The <c>capCaptureStop</c> macro stops the capture operation. You can use this macro or explicitly send the WM_CAP_STOP message.
/// </para>
/// <para>
/// In step frame capture, the image data that was collected before this message was sent is retained in the capture file. An
/// equivalent duration of audio data is also retained in the capture file if audio capture was enabled.
/// </para>
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <returns>None</returns>
/// <remarks>
/// The capture operation must yield to use this message. Use the capCaptureAbort macro to abandon the current capture operation.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capcapturestop void capCaptureStop( hwnd );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capCaptureStop")]
public static bool capCaptureStop(HWND hwnd) => AVICapSM(hwnd, capMessage.WM_CAP_STOP);
/// <summary>The <c>capCreateCaptureWindow</c> function creates a capture window.</summary>
/// <param name="lpszWindowName">Null-terminated string containing the name used for the capture window.</param>
/// <param name="dwStyle">Window styles used for the capture window. Window styles are described with the CreateWindowEx function.</param>
/// <param name="x">The x-coordinate of the upper left corner of the capture window.</param>
/// <param name="y">The y-coordinate of the upper left corner of the capture window.</param>
/// <param name="nWidth">Width of the capture window.</param>
/// <param name="nHeight">Height of the capture window.</param>
/// <param name="hwndParent">Handle to the parent window.</param>
/// <param name="nID">Window identifier.</param>
/// <returns>Returns a handle of the capture window if successful or <c>NULL</c> otherwise.</returns>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capcreatecapturewindowa HWND VFWAPI capCreateCaptureWindowA( LPCSTR
// lpszWindowName, DWORD dwStyle, int x, int y, int nWidth, int nHeight, HWND hwndParent, int nID );
[DllImport(Lib_Avicap32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capCreateCaptureWindowA")]
public static extern HWND capCreateCaptureWindow([MarshalAs(UnmanagedType.LPTStr)] string lpszWindowName, User32.WindowStyles dwStyle, int x, int y, int nWidth, int nHeight, [In, Optional] HWND hwndParent, int nID);
/// <summary>
/// The <c>capDlgVideoCompression</c> macro displays a dialog box in which the user can select a compressor to use during the
/// capture process. The list of available compressors can vary with the video format selected in the capture driver's Video Format
/// dialog box. You can use this macro or explicitly send the WM_CAP_DLG_VIDEOCOMPRESSION message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <returns>None</returns>
/// <remarks>
/// <para>
/// Use this message with capture drivers that provide frames only in the BI_RGB format. This message is most useful in the step
/// capture operation to combine capture and compression in a single operation. Compressing frames with a software compressor as
/// part of a real-time capture operation is most likely too time-consuming to perform.
/// </para>
/// <para>Compression does not affect the frames copied to the clipboard.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capdlgvideocompression void capDlgVideoCompression( hwnd );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capDlgVideoCompression")]
public static bool capDlgVideoCompression(HWND hwnd) => AVICapSM(hwnd, capMessage.WM_CAP_DLG_VIDEOCOMPRESSION);
/// <summary>
/// The <c>capDlgVideoDisplay</c> macro displays a dialog box in which the user can set or adjust the video output. This dialog box
/// might contain controls that affect the hue, contrast, and brightness of the displayed image, as well as key color alignment. You
/// can use this macro or explicitly send the WM_CAP_DLG_VIDEODISPLAY message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <returns>None</returns>
/// <remarks>
/// <para>
/// The controls in this dialog box do not affect digitized video data; they affect only the output or redisplay of the video signal.
/// </para>
/// <para>
/// The Video Display dialog box is unique for each capture driver. Some capture drivers might not support a Video Display dialog
/// box. Applications can determine if the capture driver supports this message by checking the <c>fHasDlgVideoDisplay</c> member of
/// the CAPDRIVERCAPS structure.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capdlgvideodisplay void capDlgVideoDisplay( hwnd );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capDlgVideoDisplay")]
public static bool capDlgVideoDisplay(HWND hwnd) => AVICapSM(hwnd, capMessage.WM_CAP_DLG_VIDEODISPLAY);
/// <summary>
/// The <c>capDlgVideoFormat</c> macro displays a dialog box in which the user can select the video format. The Video Format dialog
/// box might be used to select image dimensions, bit depth, and hardware compression options. You can use this macro or explicitly
/// send the WM_CAP_DLG_VIDEOFORMAT message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <returns>None</returns>
/// <remarks>
/// <para>
/// After this message returns, applications might need to update the CAPSTATUS structure because the user might have changed the
/// image dimensions.
/// </para>
/// <para>
/// The Video Format dialog box is unique for each capture driver. Some capture drivers might not support a Video Format dialog box.
/// Applications can determine if the capture driver supports this message by checking the <c>fHasDlgVideoFormat</c> member of CAPDRIVERCAPS.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capdlgvideoformat void capDlgVideoFormat( hwnd );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capDlgVideoFormat")]
public static bool capDlgVideoFormat(HWND hwnd) => AVICapSM(hwnd, capMessage.WM_CAP_DLG_VIDEOFORMAT);
/// <summary>
/// The <c>capDlgVideoSource</c> macro displays a dialog box in which the user can control the video source. The Video Source dialog
/// box might contain controls that select input sources; alter the hue, contrast, brightness of the image; and modify the video
/// quality before digitizing the images into the frame buffer. You can use this macro or explicitly send the WM_CAP_DLG_VIDEOSOURCE message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <returns>None</returns>
/// <remarks>
/// The Video Source dialog box is unique for each capture driver. Some capture drivers might not support a Video Source dialog box.
/// Applications can determine if the capture driver supports this message by checking the <c>fHasDlgVideoSource</c> member of the
/// CAPDRIVERCAPS structure.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capdlgvideosource void capDlgVideoSource( hwnd );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capDlgVideoSource")]
public static bool capDlgVideoSource(HWND hwnd) => AVICapSM(hwnd, capMessage.WM_CAP_DLG_VIDEOSOURCE);
/// <summary>
/// The <c>capDriverConnect</c> macro connects a capture window to a capture driver. You can use this macro or explicitly send the
/// WM_CAP_DRIVER_CONNECT message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="i">Index of the capture driver. The index can range from 0 through 9.</param>
/// <returns>None</returns>
/// <remarks>Connecting a capture driver to a capture window automatically disconnects any previously connected capture driver.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capdriverconnect void capDriverConnect( hwnd, i );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capDriverConnect")]
public static bool capDriverConnect(HWND hwnd, int i) => AVICapSM(hwnd, capMessage.WM_CAP_DRIVER_CONNECT, (IntPtr)i);
/// <summary>
/// The <c>capDriverDisconnect</c> macro disconnects a capture driver from a capture window. You can use this macro or explicitly
/// send the WM_CAP_DRIVER_DISCONNECT message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <returns>None</returns>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capdriverdisconnect void capDriverDisconnect( hwnd );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capDriverDisconnect")]
public static bool capDriverDisconnect(HWND hwnd) => AVICapSM(hwnd, capMessage.WM_CAP_DRIVER_DISCONNECT);
/// <summary>
/// The <c>capDriverGetCaps</c> macro returns the hardware capabilities of the capture driver currently connected to a capture
/// window. You can use this macro or explicitly send the WM_CAP_DRIVER_GET_CAPS message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="s">Pointer to the CAPDRIVERCAPS structure to contain the hardware capabilities.</param>
/// <returns>None</returns>
/// <remarks>
/// The capabilities returned in CAPDRIVERCAPS are constant for a given capture driver. Applications need to retrieve this
/// information once when the capture driver is first connected to a capture window.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capdrivergetcaps void capDriverGetCaps( hwnd, s, wSize );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capDriverGetCaps")]
public static bool capDriverGetCaps(HWND hwnd, out CAPDRIVERCAPS s) => AVICapSM(hwnd, capMessage.WM_CAP_DRIVER_GET_CAPS, out s) != 0;
/// <summary>
/// The <c>capDriverGetName</c> macro returns the name of the capture driver connected to the capture window. You can use this macro
/// or explicitly call the WM_CAP_DRIVER_GET_NAME message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="szName">Pointer to an application-defined buffer used to return the device name as a null-terminated string.</param>
/// <returns>None</returns>
/// <remarks>
/// The name is a text string retrieved from the driver's resource area. Applications should allocate approximately 80 bytes for
/// this string. If the driver does not contain a name resource, the full path name of the driver listed in the registry or in the
/// SYSTEM.INI file is returned.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capdrivergetname void capDriverGetName( hwnd, szName, wSize );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capDriverGetName")]
public static bool capDriverGetName(HWND hwnd, StringBuilder szName) => AVICapSM(hwnd, capMessage.WM_CAP_DRIVER_GET_NAME, szName);
/// <summary>
/// The <c>capDriverGetVersion</c> macro returns the version information of the capture driver connected to a capture window. You
/// can use this macro or explicitly send the WM_CAP_DRIVER_GET_VERSION message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="szVer">Pointer to an application-defined buffer used to return the version information as a null-terminated string.</param>
/// <returns>None</returns>
/// <remarks>
/// The version information is a text string retrieved from the driver's resource area. Applications should allocate approximately
/// 40 bytes for this string. If version information is not available, a <c>NULL</c> string is returned.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capdrivergetversion void capDriverGetVersion( hwnd, szVer, wSize );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capDriverGetVersion")]
public static bool capDriverGetVersion(HWND hwnd, StringBuilder szVer) => AVICapSM(hwnd, capMessage.WM_CAP_DRIVER_GET_VERSION, szVer);
/// <summary>
/// The <c>capEditCopy</c> macro copies the contents of the video frame buffer and associated palette to the clipboard. You can use
/// this macro or explicitly send the WM_CAP_EDIT_COPY message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <returns>None</returns>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capeditcopy void capEditCopy( hwnd );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capEditCopy")]
public static bool capEditCopy(HWND hwnd) => AVICapSM(hwnd, capMessage.WM_CAP_EDIT_COPY);
/// <summary>
/// The <c>capFileAlloc</c> macro creates (preallocates) a capture file of a specified size. You can use this macro or explicitly
/// send the WM_CAP_FILE_ALLOCATE message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="dwSize">Size, in bytes, to create the capture file.</param>
/// <returns>None</returns>
/// <remarks>
/// You can improve streaming capture performance significantly by preallocating a capture file large enough to store an entire
/// video clip and by defragmenting the capture file before capturing the clip.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capfilealloc void capFileAlloc( hwnd, dwSize );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capFileAlloc")]
public static bool capFileAlloc(HWND hwnd, int dwSize) => AVICapSM(hwnd, capMessage.WM_CAP_FILE_ALLOCATE, (IntPtr)0, (IntPtr)dwSize);
/// <summary>
/// The <c>capFileGetCaptureFile</c> macro returns the name of the current capture file. You can use this macro or explicitly call
/// the WM_CAP_FILE_GET_CAPTURE_FILE message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="szName">
/// Pointer to an application-defined buffer used to return the name of the capture file as a null-terminated string.
/// </param>
/// <returns>None</returns>
/// <remarks>The default capture filename is C:\CAPTURE.AVI.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capfilegetcapturefile void capFileGetCaptureFile( hwnd, szName,
// wSize );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capFileGetCaptureFile")]
public static bool capFileGetCaptureFile(HWND hwnd, StringBuilder szName) => AVICapSM(hwnd, capMessage.WM_CAP_FILE_GET_CAPTURE_FILE, szName);
/// <summary>
/// The <c>capFileSaveAs</c> macro copies the contents of the capture file to another file. You can use this macro or explicitly
/// call the WM_CAP_FILE_SAVEAS message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="szName">
/// Pointer to the null-terminated string that contains the name of the destination file used to copy the file.
/// </param>
/// <returns>None</returns>
/// <remarks>
/// <para>This message does not change the name or contents of the current capture file.</para>
/// <para>If the copy operation is unsuccessful due to a disk full error, the destination file is automatically deleted.</para>
/// <para>
/// Typically, a capture file is preallocated for the largest capture segment anticipated and only a portion of it might be used to
/// capture data. This message copies only the portion of the file containing the capture data.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capfilesaveas void capFileSaveAs( hwnd, szName );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capFileSaveAs")]
public static bool capFileSaveAs(HWND hwnd, string szName) => AVICapSM(hwnd, capMessage.WM_CAP_FILE_SAVEAS, szName);
/// <summary>
/// The <c>capFileSaveDIB</c> macro copies the current frame to a DIB file. You can use this macro or explicitly call the
/// WM_CAP_FILE_SAVEDIB message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="szName">Pointer to the null-terminated string that contains the name of the destination DIB file.</param>
/// <returns>None</returns>
/// <remarks>
/// If the capture driver supplies frames in a compressed format, this call attempts to decompress the frame before writing the file.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capfilesavedib void capFileSaveDIB( hwnd, szName );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capFileSaveDIB")]
public static bool capFileSaveDIB(HWND hwnd, string szName) => AVICapSM(hwnd, capMessage.WM_CAP_FILE_SAVEDIB, szName);
/// <summary>
/// The <c>capFileSetCaptureFile</c> macro names the file used for video capture. You can use this macro or explicitly call the
/// WM_CAP_FILE_SET_CAPTURE_FILE message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="szName">Pointer to the null-terminated string that contains the name of the capture file to use.</param>
/// <returns>None</returns>
/// <remarks>
/// This message stores the filename in an internal structure. It does not create, allocate, or open the specified file. The default
/// capture filename is C:\CAPTURE.AVI.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capfilesetcapturefile void capFileSetCaptureFile( hwnd, szName );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capFileSetCaptureFile")]
public static bool capFileSetCaptureFile(HWND hwnd, string szName) => AVICapSM(hwnd, capMessage.WM_CAP_FILE_SET_CAPTURE_FILE, szName);
/// <summary>
/// The <c>capFileSetInfoChunk</c> macro sets and clears information chunks. Information chunks can be inserted in an AVI file
/// during capture to embed text strings or custom data. You can use this macro or explicitly call the WM_CAP_FILE_SET_INFOCHUNK message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="lpInfoChunk">Pointer to a CAPINFOCHUNK structure defining the information chunk to be created or deleted.</param>
/// <returns>None</returns>
/// <remarks>
/// Multiple registered information chunks can be added to an AVI file. After an information chunk is set, it continues to be added
/// to subsequent capture files until either the entry is cleared or all information chunk entries are cleared. To clear a single
/// entry, specify the information chunk in the <c>fccInfoID</c> member and <c>NULL</c> in the <c>lpData</c> member of the
/// CAPINFOCHUNK structure. To clear all entries, specify <c>NULL</c> in <c>fccInfoID</c>.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capfilesetinfochunk void capFileSetInfoChunk( hwnd, lpInfoChunk );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capFileSetInfoChunk")]
public static bool capFileSetInfoChunk(HWND hwnd, out CAPINFOCHUNK lpInfoChunk) => AVICapSM(hwnd, capMessage.WM_CAP_FILE_SET_INFOCHUNK, out lpInfoChunk, 0) != 0;
/// <summary>
/// The <c>capGetAudioFormat</c> macro obtains the audio format. You can use this macro or explicitly call the
/// WM_CAP_GET_AUDIOFORMAT message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="s">
/// Pointer to a WAVEFORMATEX structure, or <c>NULL</c>. If the value is <c>NULL</c>, the size, in bytes, required to hold the
/// <c>WAVEFORMATEX</c> structure is returned.
/// </param>
/// <param name="wSize">Size, in bytes, of the structure referenced by s.</param>
/// <returns>None</returns>
/// <remarks>
/// Because compressed audio formats vary in size requirements applications must first retrieve the size, then allocate memory, and
/// finally request the audio format data.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capgetaudioformat void capGetAudioFormat( hwnd, s, wSize );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capGetAudioFormat")]
public static int capGetAudioFormat(HWND hwnd, IntPtr s, int wSize) => User32.SendMessage(hwnd, capMessage.WM_CAP_GET_AUDIOFORMAT, (IntPtr)wSize, s).ToInt32();
/// <summary>
/// The <c>capGetAudioFormatSize</c> macro obtains the size of the audio format. You can use this macro or explicitly call the
/// WM_CAP_GET_AUDIOFORMAT message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <returns>None</returns>
/// <remarks>
/// Because compressed audio formats vary in size requirements applications must first retrieve the size, then allocate memory, and
/// finally request the audio format data.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capgetaudioformatsize void capGetAudioFormatSize( hwnd );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capGetAudioFormatSize")]
public static int capGetAudioFormatSize(HWND hwnd) => User32.SendMessage(hwnd, capMessage.WM_CAP_GET_AUDIOFORMAT).ToInt32();
/// <summary>The <c>capGetDriverDescription</c> function retrieves the version description of the capture driver.</summary>
/// <param name="wDriverIndex">
/// <para>Index of the capture driver. The index can range from 0 through 9.</para>
/// <para>
/// Plug-and-Play capture drivers are enumerated first, followed by capture drivers listed in the registry, which are then followed
/// by capture drivers listed in SYSTEM.INI.
/// </para>
/// </param>
/// <param name="lpszName">Pointer to a buffer containing a null-terminated string corresponding to the capture driver name.</param>
/// <param name="cbName">Length, in bytes, of the buffer pointed to by lpszName.</param>
/// <param name="lpszVer">
/// Pointer to a buffer containing a null-terminated string corresponding to the description of the capture driver.
/// </param>
/// <param name="cbVer">Length, in bytes, of the buffer pointed to by lpszVer.</param>
/// <returns>Returns <c>TRUE</c> if successful or <c>FALSE</c> otherwise.</returns>
/// <remarks>
/// <para>
/// If the information description is longer than its buffer, the description is truncated. The returned string is always
/// null-terminated. If a buffer size is zero, its corresponding description is not copied.
/// </para>
/// <para>
/// <para>Note</para>
/// <para>
/// The vfw.h header defines capGetDriverDescription as an alias which automatically selects the ANSI or Unicode version of this
/// function based on the definition of the UNICODE preprocessor constant. Mixing usage of the encoding-neutral alias with code that
/// not encoding-neutral can lead to mismatches that result in compilation or runtime errors. For more information, see Conventions
/// for Function Prototypes.
/// </para>
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capgetdriverdescriptiona BOOL VFWAPI capGetDriverDescriptionA( UINT
// wDriverIndex, LPSTR lpszName, int cbName, LPSTR lpszVer, int cbVer );
[DllImport(Lib_Avicap32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capGetDriverDescriptionA")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool capGetDriverDescription(uint wDriverIndex, [MarshalAs(UnmanagedType.LPTStr)] StringBuilder lpszName, int cbName, [MarshalAs(UnmanagedType.LPTStr)] StringBuilder lpszVer, int cbVer);
/// <summary>
/// The <c>capGetMCIDeviceName</c> macro retrieves the name of an MCI device previously set with the capSetMCIDeviceName macro. You
/// can use this macro or explicitly call the WM_CAP_GET_MCI_DEVICE message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="szName">Pointer to a null-terminated string that contains the MCI device name.</param>
/// <returns>None</returns>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capgetmcidevicename void capGetMCIDeviceName( hwnd, szName, wSize );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capGetMCIDeviceName")]
public static bool capGetMCIDeviceName(HWND hwnd, StringBuilder szName) => AVICapSM(hwnd, capMessage.WM_CAP_GET_MCI_DEVICE, szName);
/// <summary>
/// The <c>capGetStatus</c> macro retrieves the status of the capture window. You can use this macro or explicitly call the
/// WM_CAP_GET_STATUS message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="s">Pointer to a CAPSTATUS structure.</param>
/// <returns>None</returns>
/// <remarks>
/// The CAPSTATUS structure contains the current state of the capture window. Since this state is dynamic and changes in response to
/// various messages, the application should initialize this structure after sending the capDlgVideoFormat macro and whenever it
/// needs to enable menu items or determine the actual state of the window.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capgetstatus void capGetStatus( hwnd, s, wSize );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capGetStatus")]
public static bool capGetStatus(HWND hwnd, out CAPSTATUS s) => AVICapSM(hwnd, capMessage.WM_CAP_GET_STATUS, out s) != 0;
/// <summary>
/// The <c>capGetUserData</c> macro retrieves a <c>LONG_PTR</c> data value associated with a capture window. You can use this macro
/// or explicitly call the WM_CAP_GET_USER_DATA message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <returns>Returns a value previously saved by using the WM_CAP_SET_USER_DATA message.</returns>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capgetuserdata void capGetUserData( hwnd );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capGetUserData")]
public static IntPtr capGetUserData(HWND hwnd) => User32.SendMessage(hwnd, capMessage.WM_CAP_GET_USER_DATA);
/// <summary>
/// The <c>capGetVideoFormat</c> macro retrieves a copy of the video format in use. You can use this macro or explicitly call the
/// WM_CAP_GET_VIDEOFORMAT message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="s">
/// Pointer to a BITMAPINFO structure. You can also specify <c>NULL</c> to retrieve the number of bytes needed by <c>BITMAPINFO</c>.
/// </param>
/// <returns>None</returns>
/// <remarks>
/// Because compressed video formats vary in size requirements applications must first retrieve the size, then allocate memory, and
/// finally request the video format data.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capgetvideoformat void capGetVideoFormat( hwnd, s, wSize );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capGetVideoFormat")]
public static int capGetVideoFormat(HWND hwnd, [Out] Gdi32.SafeBITMAPINFO s) => User32.SendMessage(hwnd, capMessage.WM_CAP_GET_VIDEOFORMAT, (IntPtr)(int)s.Size, s.DangerousGetHandle()).ToInt32();
/// <summary>
/// The <c>capGetVideoFormatSize</c> macro retrieves the size required for the video format. You can use this macro or explicitly
/// call the WM_CAP_GET_VIDEOFORMAT message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <returns>None</returns>
/// <remarks>
/// Because compressed video formats vary in size requirements applications must first retrieve the size, then allocate memory, and
/// finally request the video format data.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capgetvideoformatsize void capGetVideoFormatSize( hwnd );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capGetVideoFormatSize")]
public static int capGetVideoFormatSize(HWND hwnd) => User32.SendMessage(hwnd, capMessage.WM_CAP_GET_VIDEOFORMAT).ToInt32();
/// <summary>
/// The <c>capGrabFrame</c> macro retrieves and displays a single frame from the capture driver. After capture, overlay and preview
/// are disabled. You can use this macro or explicitly call the WM_CAP_GRAB_FRAME message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <returns>None</returns>
/// <remarks>For information about installing callback functions, see the capSetCallbackOnError and capSetCallbackOnFrame macros.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capgrabframe void capGrabFrame( hwnd );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capGrabFrame")]
public static bool capGrabFrame(HWND hwnd) => AVICapSM(hwnd, capMessage.WM_CAP_GRAB_FRAME);
/// <summary>
/// The <c>capGrabFrameNoStop</c> macro fills the frame buffer with a single uncompressed frame from the capture device and displays
/// it. Unlike with the capGrabFrame macro, the state of overlay or preview is not altered by this message. You can use this macro
/// or explicitly call the WM_CAP_GRAB_FRAME_NOSTOP message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <returns>None</returns>
/// <remarks>
/// For information about installing callback functions, see the <c>capSetCallbackOnError</c> and <c>capSetCallbackOnFrame</c> macros.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capgrabframenostop void capGrabFrameNoStop( hwnd );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capGrabFrameNoStop")]
public static bool capGrabFrameNoStop(HWND hwnd) => AVICapSM(hwnd, capMessage.WM_CAP_GRAB_FRAME_NOSTOP);
/// <summary>
/// The <c>capOverlay</c> macro enables or disables overlay mode. In overlay mode, video is displayed using hardware overlay. You
/// can use this macro or explicitly call the WM_CAP_SET_OVERLAY message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="f">Overlay flag. Specify <c>TRUE</c> for this parameter to enable overlay mode or <c>FALSE</c> to disable it.</param>
/// <returns>None</returns>
/// <remarks>
/// <para>Using an overlay does not require CPU resources.</para>
/// <para>
/// The <c>fHasOverlay</c> member of the <c>CAPDRIVERCAPS</c> structure indicates whether the device is capable of overlay. The
/// <c>fOverlayWindow</c> member of the <c>CAPSTATUS</c> structure indicates whether overlay mode is currently enabled.
/// </para>
/// <para>Enabling overlay mode automatically disables preview mode.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capoverlay void capOverlay( hwnd, f );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capOverlay")]
public static bool capOverlay(HWND hwnd, bool f) => AVICapSM(hwnd, capMessage.WM_CAP_SET_OVERLAY, (IntPtr)(f ? 1 : 0));
/// <summary>
/// The <c>capPaletteAuto</c> macro requests that the capture driver sample video frames and automatically create a new palette. You
/// can use this macro or explicitly call the WM_CAP_PAL_AUTOCREATE message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="iFrames">Number of frames to sample.</param>
/// <param name="iColors">Number of colors in the palette. The maximum value for this parameter is 256.</param>
/// <returns>None</returns>
/// <remarks>
/// The sampled video sequence should include all the colors you want in the palette. To obtain the best palette, you might have to
/// sample the whole sequence rather than a portion of it.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-cappaletteauto void capPaletteAuto( hwnd, iFrames, iColors );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capPaletteAuto")]
public static bool capPaletteAuto(HWND hwnd, int iFrames, int iColors) => AVICapSM(hwnd, capMessage.WM_CAP_PAL_AUTOCREATE, (IntPtr)iFrames, (IntPtr)iColors);
/// <summary>
/// The <c>capPaletteManual</c> macro requests that the capture driver manually sample video frames and create a new palette. You
/// can use this macro or explicitly call the WM_CAP_PAL_MANUALCREATE message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="fGrab">
/// Palette histogram flag. Set this parameter to <c>TRUE</c> for each frame included in creating the optimal palette. After the
/// last frame has been collected, set this parameter to <c>FALSE</c> to calculate the optimal palette and send it to the capture driver.
/// </param>
/// <param name="iColors">
/// Number of colors in the palette. The maximum value for this parameter is 256. This value is used only during collection of the
/// first frame in a sequence.
/// </param>
/// <returns>None</returns>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-cappalettemanual void capPaletteManual( hwnd, fGrab, iColors );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capPaletteManual")]
public static bool capPaletteManual(HWND hwnd, bool fGrab, int iColors) => AVICapSM(hwnd, capMessage.WM_CAP_PAL_MANUALCREATE, (IntPtr)(fGrab ? 1 : 0), (IntPtr)iColors);
/// <summary>
/// The <c>capPaletteOpen</c> macro loads a new palette from a palette file and passes it to a capture driver. Palette files
/// typically use the filename extension .PAL. A capture driver uses a palette when required by the specified digitized image
/// format. You can use this macro or explicitly call the WM_CAP_PAL_OPEN message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="szName">Pointer to a null-terminated string containing the palette filename.</param>
/// <returns>None</returns>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-cappaletteopen void capPaletteOpen( hwnd, szName );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capPaletteOpen")]
public static bool capPaletteOpen(HWND hwnd, string szName) => AVICapSM(hwnd, capMessage.WM_CAP_PAL_OPEN, szName);
/// <summary>
/// The <c>capPalettePaste</c> macro copies the palette from the clipboard and passes it to a capture driver. You can use this macro
/// or explicitly call the WM_CAP_PAL_PASTE message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <returns>None</returns>
/// <remarks>A capture driver uses a palette when required by the specified digitized video format.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-cappalettepaste void capPalettePaste( hwnd );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capPalettePaste")]
public static bool capPalettePaste(HWND hwnd) => AVICapSM(hwnd, capMessage.WM_CAP_PAL_PASTE);
/// <summary>
/// The <c>capPaletteSave</c> macro saves the current palette to a palette file. Palette files typically use the filename extension
/// .PAL. You can use this macro or explicitly send the WM_CAP_PAL_SAVE message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="szName">Pointer to a null-terminated string containing the palette filename.</param>
/// <returns>None</returns>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-cappalettesave void capPaletteSave( hwnd, szName );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capPaletteSave")]
public static bool capPaletteSave(HWND hwnd, string szName) => AVICapSM(hwnd, capMessage.WM_CAP_PAL_SAVE, szName);
/// <summary>
/// The <c>capPreview</c> macro enables or disables preview mode. In preview mode, frames are transferred from the capture hardware
/// to system memory and then displayed in the capture window using GDI functions. You can use this macro or explicitly call the
/// WM_CAP_SET_PREVIEW message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="f">Preview flag. Specify <c>TRUE</c> for this parameter to enable preview mode or <c>FALSE</c> to disable it.</param>
/// <returns>None</returns>
/// <remarks>
/// <para>
/// The preview mode uses substantial CPU resources. Applications can disable preview or lower the preview rate when another
/// application has the focus. The <c>fLiveWindow</c> member of the CAPSTATUS structure indicates if preview mode is currently enabled.
/// </para>
/// <para>Enabling preview mode automatically disables overlay mode.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-cappreview void capPreview( hwnd, f );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capPreview")]
public static bool capPreview(HWND hwnd, bool f) => AVICapSM(hwnd, capMessage.WM_CAP_SET_PREVIEW, (IntPtr)(f ? 1 : 0));
/// <summary>
/// The <c>capPreviewRate</c> macro sets the frame display rate in preview mode. You can use this macro or explicitly call the
/// WM_CAP_SET_PREVIEWRATE message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="wMS">Rate, in milliseconds, at which new frames are captured and displayed.</param>
/// <returns>None</returns>
/// <remarks>
/// The preview mode uses substantial CPU resources. Applications can disable preview or lower the preview rate when another
/// application has the focus. During streaming video capture, the previewing task is lower priority than writing frames to disk,
/// and preview frames are displayed only if no other buffers are available for writing.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-cappreviewrate void capPreviewRate( hwnd, wMS );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capPreviewRate")]
public static bool capPreviewRate(HWND hwnd, int wMS) => AVICapSM(hwnd, capMessage.WM_CAP_SET_PREVIEWRATE, (IntPtr)wMS);
/// <summary>
/// The <c>capPreviewScale</c> macro enables or disables scaling of the preview video images. If scaling is enabled, the captured
/// video frame is stretched to the dimensions of the capture window. You can use this macro or explicitly call the WM_CAP_SET_SCALE message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="f">
/// Preview scaling flag. Specify <c>TRUE</c> for this parameter to stretch preview frames to the size of the capture window or
/// <c>FALSE</c> to display them at their natural size.
/// </param>
/// <returns>None</returns>
/// <remarks>
/// <para>
/// Scaling preview images controls the immediate presentation of captured frames within the capture window. It has no effect on the
/// size of the frames saved to file.
/// </para>
/// <para>Scaling has no effect when using overlay to display video in the frame buffer.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-cappreviewscale void capPreviewScale( hwnd, f );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capPreviewScale")]
public static bool capPreviewScale(HWND hwnd, bool f) => AVICapSM(hwnd, capMessage.WM_CAP_SET_SCALE, (IntPtr)(f ? 1 : 0));
/// <summary>
/// The <c>capSetAudioFormat</c> macro sets the audio format to use when performing streaming or step capture. You can use this
/// macro or explicitly call the WM_CAP_SET_AUDIOFORMAT message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="s">Pointer to a WAVEFORMATEX or PCMWAVEFORMAT structure that defines the audio format.</param>
/// <returns>None</returns>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capsetaudioformat void capSetAudioFormat( hwnd, s, wSize );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capSetAudioFormat")]
public static bool capSetAudioFormat(HWND hwnd, in WAVEFORMATEX s) => AVICapSM(hwnd, capMessage.WM_CAP_SET_AUDIOFORMAT, -1, s) != 0;
/// <summary>
/// The <c>capSetAudioFormat</c> macro sets the audio format to use when performing streaming or step capture. You can use this
/// macro or explicitly call the WM_CAP_SET_AUDIOFORMAT message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="s">Pointer to a WAVEFORMATEX or PCMWAVEFORMAT structure that defines the audio format.</param>
/// <returns>None</returns>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capsetaudioformat void capSetAudioFormat( hwnd, s, wSize );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capSetAudioFormat")]
public static bool capSetAudioFormat(HWND hwnd, in PCMWAVEFORMAT s) => AVICapSM(hwnd, capMessage.WM_CAP_SET_AUDIOFORMAT, -1, s) != 0;
/// <summary>
/// The <c>capSetCallbackOnCapControl</c> macro sets a callback function in the application giving it precise recording control. You
/// can use this macro or explicitly call the WM_CAP_SET_CALLBACK_CAPCONTROL message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="fpProc">
/// Pointer to the callback function, of type capControlCallback . Specify <c>NULL</c> for this parameter to disable a previously
/// installed callback function.
/// </param>
/// <returns>None</returns>
/// <remarks>
/// A single callback function is used to give the application precise control over the moments that streaming capture begins and
/// completes. The capture window first calls the procedure with nState set to CONTROLCALLBACK_PREROLL after all buffers have been
/// allocated and all other capture preparations have finished. This gives the application the ability to preroll video sources,
/// returning from the callback function at the exact moment recording is to begin. A return value of <c>TRUE</c> from the callback
/// function continues capture, and a return value of <c>FALSE</c> aborts capture. After capture begins, this callback function will
/// be called frequently with nState set to CONTROLCALLBACK_CAPTURING to allow the application to end capture by returning <c>FALSE</c>.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capsetcallbackoncapcontrol void capSetCallbackOnCapControl( hwnd,
// fpProc );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capSetCallbackOnCapControl")]
public static bool capSetCallbackOnCapControl(HWND hwnd, [Optional] capControlCallback fpProc) => AVICapSM(hwnd, capMessage.WM_CAP_SET_CALLBACK_CAPCONTROL, 0, fpProc);
/// <summary>
/// The <c>capSetCallbackOnError</c> macro sets an error callback function in the client application. AVICap calls this procedure
/// when errors occur. You can use this macro or explicitly call the WM_CAP_SET_CALLBACK_ERROR message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="fpProc">
/// Pointer to the error callback function, of type capErrorCallback. Specify <c>NULL</c> for this parameter to disable a previously
/// installed error callback function.
/// </param>
/// <returns>None</returns>
/// <remarks>
/// <para>
/// Applications can optionally set an error callback function. If set, AVICap calls the error procedure in the following situations:
/// </para>
/// <list type="bullet">
/// <item>
/// <term>The disk is full.</term>
/// </item>
/// <item>
/// <term>A capture window cannot be connected with a capture driver.</term>
/// </item>
/// <item>
/// <term>A waveform-audio device cannot be opened.</term>
/// </item>
/// <item>
/// <term>The number of frames dropped during capture exceeds the specified percentage.</term>
/// </item>
/// <item>
/// <term>The frames cannot be captured due to vertical synchronization interrupt problems.</term>
/// </item>
/// </list>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capsetcallbackonerror void capSetCallbackOnError( hwnd, fpProc );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capSetCallbackOnError")]
public static bool capSetCallbackOnError(HWND hwnd, [Optional] capErrorCallback fpProc) => AVICapSM(hwnd, capMessage.WM_CAP_SET_CALLBACK_ERROR, 0, fpProc);
/// <summary>
/// The <c>capSetCallbackOnFrame</c> macro sets a preview callback function in the application. AVICap calls this procedure when the
/// capture window captures preview frames. You can use this macro or explicitly call the WM_CAP_SET_CALLBACK_FRAME message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="fpProc">
/// Pointer to the preview callback function, of type capVideoStreamCallback. Specify <c>NULL</c> for this parameter to disable a
/// previously installed callback function.
/// </param>
/// <returns>None</returns>
/// <remarks>
/// The capture window calls the callback function before displaying preview frames. This allows an application to modify the frame
/// if desired. This callback function is not used during streaming video capture.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capsetcallbackonframe void capSetCallbackOnFrame( hwnd, fpProc );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capSetCallbackOnFrame")]
public static bool capSetCallbackOnFrame(HWND hwnd, capVideoStreamCallback fpProc) => AVICapSM(hwnd, capMessage.WM_CAP_SET_CALLBACK_FRAME, 0, fpProc);
/// <summary>
/// The <c>capSetCallbackOnStatus</c> macro sets a status callback function in the application. AVICap calls this procedure whenever
/// the capture window status changes. You can use this macro or explicitly call the WM_CAP_SET_CALLBACK_STATUS message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="fpProc">
/// Pointer to the status callback function, of type capStatusCallback. Specify <c>NULL</c> for this parameter to disable a
/// previously installed status callback function.
/// </param>
/// <returns>None</returns>
/// <remarks>
/// <para>Applications can optionally set a status callback function. If set, AVICap calls this procedure in the following situations:</para>
/// <list type="bullet">
/// <item>
/// <term>A capture session is completed.</term>
/// </item>
/// <item>
/// <term>A capture driver successfully connected to a capture window.</term>
/// </item>
/// <item>
/// <term>An optimal palette is created.</term>
/// </item>
/// <item>
/// <term>The number of captured frames is reported.</term>
/// </item>
/// </list>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capsetcallbackonstatus void capSetCallbackOnStatus( hwnd, fpProc );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capSetCallbackOnStatus")]
public static bool capSetCallbackOnStatus(HWND hwnd, [Optional] capStatusCallback fpProc) => AVICapSM(hwnd, capMessage.WM_CAP_SET_CALLBACK_STATUS, 0, fpProc);
/// <summary>
/// The <c>capSetCallbackOnVideoStream</c> macro sets a callback function in the application. AVICap calls this procedure during
/// streaming capture when a video buffer is filled. You can use this macro or explicitly call the WM_CAP_SET_CALLBACK_VIDEOSTREAM message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="fpProc">
/// Pointer to the video-stream callback function, of type capVideoStreamCallback. Specify <c>NULL</c> for this parameter to disable
/// a previously installed video-stream callback function.
/// </param>
/// <returns>None</returns>
/// <remarks>
/// <para>
/// The capture window calls the callback function before writing the captured frame to disk. This allows applications to modify the
/// frame if desired.
/// </para>
/// <para>
/// If a video stream callback function is used for streaming capture, the procedure must be installed before starting the capture
/// session and it must remain enabled for the duration of the session. It can be disabled after streaming capture ends.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capsetcallbackonvideostream void capSetCallbackOnVideoStream( hwnd,
// fpProc );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capSetCallbackOnVideoStream")]
public static bool capSetCallbackOnVideoStream(HWND hwnd, [Optional] capVideoStreamCallback fpProc) => AVICapSM(hwnd, capMessage.WM_CAP_SET_CALLBACK_VIDEOSTREAM, 0, fpProc);
/// <summary>
/// The <c>capSetCallbackOnWaveStream</c> macro sets a callback function in the application. AVICap calls this procedure during
/// streaming capture when a new audio buffer becomes available. You can use this macro or explicitly call the
/// WM_CAP_SET_CALLBACK_WAVESTREAM message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="fpProc">
/// Pointer to the wave stream callback function, of type capWaveStreamCallback. Specify <c>NULL</c> for this parameter to disable a
/// previously installed wave stream callback function.
/// </param>
/// <returns>None</returns>
/// <remarks>
/// <para>
/// The capture window calls the procedure before writing the audio buffer to disk. This allows applications to modify the audio
/// buffer if desired.
/// </para>
/// <para>
/// If a wave stream callback function is used, it must be installed before starting the capture session and it must remain enabled
/// for the duration of the session. It can be disabled after streaming capture ends.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capsetcallbackonwavestream void capSetCallbackOnWaveStream( hwnd,
// fpProc );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capSetCallbackOnWaveStream")]
public static bool capSetCallbackOnWaveStream(HWND hwnd, [Optional] capWaveStreamCallback fpProc) => AVICapSM(hwnd, capMessage.WM_CAP_SET_CALLBACK_WAVESTREAM, 0, fpProc);
/// <summary>
/// The <c>capSetCallbackOnYield</c> macro sets a callback function in the application. AVICap calls this procedure when the capture
/// window yields during streaming capture. You can use this macro or explicitly call the WM_CAP_SET_CALLBACK_YIELD message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="fpProc">
/// Pointer to the yield callback function, of type capYieldCallback. Specify <c>NULL</c> for this parameter to disable a previously
/// installed yield callback function.
/// </param>
/// <returns>None</returns>
/// <remarks>
/// <para>
/// Applications can optionally set a yield callback function. The yield callback function is called at least once for each video
/// frame captured during streaming capture. If a yield callback function is installed, it will be called regardless of the state of
/// the <c>fYield</c> member of the CAPTUREPARMS structure.
/// </para>
/// <para>
/// If the yield callback function is used, it must be installed before starting the capture session and it must remain enabled for
/// the duration of the session. It can be disabled after streaming capture ends.
/// </para>
/// <para>
/// Applications typically perform some type of message processing in the callback function consisting of a PeekMessage,
/// TranslateMessage, DispatchMessage loop, as in the message loop of a WinMain function. The yield callback function must also
/// filter and remove messages that can cause reentrancy problems.
/// </para>
/// <para>
/// An application typically returns <c>TRUE</c> in the yield procedure to continue streaming capture. If a yield callback function
/// returns <c>FALSE</c>, the capture window stops the capture process.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capsetcallbackonyield void capSetCallbackOnYield( hwnd, fpProc );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capSetCallbackOnYield")]
public static bool capSetCallbackOnYield(HWND hwnd, [Optional] capYieldCallback fpProc) => AVICapSM(hwnd, capMessage.WM_CAP_SET_CALLBACK_YIELD, 0, fpProc);
/// <summary>
/// The <c>capSetMCIDeviceName</c> macro specifies the name of the MCI video device to be used to capture data. You can use this
/// macro or explicitly call the WM_CAP_SET_MCI_DEVICE message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="szName">Pointer to a null-terminated string containing the name of the device.</param>
/// <returns>None</returns>
/// <remarks>
/// This message stores the MCI device name in an internal structure. It does not open or access the device. The default device name
/// is <c>NULL</c>.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capsetmcidevicename void capSetMCIDeviceName( hwnd, szName );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capSetMCIDeviceName")]
public static bool capSetMCIDeviceName(HWND hwnd, string szName) => AVICapSM(hwnd, capMessage.WM_CAP_SET_MCI_DEVICE, szName);
/// <summary>
/// The <c>capSetScrollPos</c> macro defines the portion of the video frame to display in the capture window. This message sets the
/// upper left corner of the client area of the capture window to the coordinates of a specified pixel within the video frame. You
/// can use this macro or explicitly call the WM_CAP_SET_SCROLL message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="lpP">Address to contain the desired scroll position.</param>
/// <returns>None</returns>
/// <remarks>The scroll position affects the image in both preview and overlay modes.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capsetscrollpos void capSetScrollPos( hwnd, lpP );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capSetScrollPos")]
public static bool capSetScrollPos(HWND hwnd, POINT lpP) => AVICapSM(hwnd, capMessage.WM_CAP_SET_SCROLL, 0, lpP) != 0;
/// <summary>
/// The <c>capSetUserData</c> macro associates a <c>LONG_PTR</c> data value with a capture window. You can use this macro or
/// explicitly call the WM_CAP_SET_USER_DATA message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="lUser">Data value to associate with a capture window.</param>
/// <returns>None</returns>
/// <remarks>Typically this message is used to point to a block of data associated with a capture window.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capsetuserdata void capSetUserData( hwnd, lUser );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capSetUserData")]
public static bool capSetUserData(HWND hwnd, IntPtr lUser) => AVICapSM(hwnd, capMessage.WM_CAP_SET_USER_DATA, default, lUser);
/// <summary>
/// The <c>capSetVideoFormat</c> macro sets the format of captured video data. You can use this macro or explicitly call the
/// WM_CAP_SET_VIDEOFORMAT message.
/// </summary>
/// <param name="hwnd">Handle to a capture window.</param>
/// <param name="s">Pointer to a BITMAPINFO structure.</param>
/// <returns>None</returns>
/// <remarks>
/// Because video formats are device-specific, applications should check the return value from this function to determine if the
/// format is accepted by the driver.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-capsetvideoformat void capSetVideoFormat( hwnd, s, wSize );
[PInvokeData("vfw.h", MSDNShortId = "NF:vfw.capSetVideoFormat")]
public static bool capSetVideoFormat(HWND hwnd, [In] Gdi32.SafeBITMAPINFO s) => AVICapSM(hwnd, capMessage.WM_CAP_SET_VIDEOFORMAT, (IntPtr)(int)s.Size, s.DangerousGetHandle());
private static bool AVICapSM(HWND hwnd, capMessage msg, int v, Delegate d) => User32.SendMessage(hwnd, unchecked((uint)msg), (IntPtr)v, Marshal.GetFunctionPointerForDelegate(d)) != IntPtr.Zero;
private static bool AVICapSM(HWND hwnd, capMessage msg, [Optional] IntPtr wparam, [Optional] IntPtr lparam) => User32.SendMessage(hwnd, unchecked((uint)msg), wparam, lparam) != IntPtr.Zero;
private static bool AVICapSM(HWND hwnd, capMessage msg, StringBuilder lparam) => User32.SendMessage(hwnd, unchecked((uint)msg), (IntPtr)(lparam?.Capacity ?? 0), lparam) != IntPtr.Zero;
private static int AVICapSM<TLP>(HWND hwnd, capMessage msg, int size, in TLP lparam) where TLP : struct
{
TLP res = lparam;
return User32.SendMessage(hwnd, msg, (IntPtr)(size == -1 ? Marshal.SizeOf(typeof(TLP)) : size), ref res).ToInt32();
}
private static int AVICapSM<TLP>(HWND hwnd, capMessage msg, out TLP lparam, int size = -1) where TLP : struct
{
TLP res = default;
var ret = User32.SendMessage(hwnd, msg, (IntPtr)(size == -1 ? Marshal.SizeOf(typeof(TLP)) : size), ref res).ToInt32();
lparam = res;
return ret;
}
private static bool AVICapSM(HWND hwnd, capMessage msg, string lparam) => User32.SendMessage(hwnd, unchecked((uint)msg), default, lparam) != IntPtr.Zero;
/// <summary>
/// <para>The <c>CAPDRIVERCAPS</c> structure defines the capabilities of the capture driver.</para>
/// <para>
/// An application should use the WM_CAP_DRIVER_GET_CAPS message or capDriverGetCaps macro to place a copy of the driver
/// capabilities in a <c>CAPDRIVERCAPS</c> structure whenever the application connects a capture window to a capture driver.
/// </para>
/// </summary>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/ns-vfw-capdrivercaps typedef struct tagCapDriverCaps { UINT wDeviceIndex;
// BOOL fHasOverlay; BOOL fHasDlgVideoSource; BOOL fHasDlgVideoFormat; BOOL fHasDlgVideoDisplay; BOOL fCaptureInitialized; BOOL
// fDriverSuppliesPalettes; HANDLE hVideoIn; HANDLE hVideoOut; HANDLE hVideoExtIn; HANDLE hVideoExtOut; } CAPDRIVERCAPS,
// *PCAPDRIVERCAPS, *LPCAPDRIVERCAPS;
[PInvokeData("vfw.h", MSDNShortId = "NS:vfw.tagCapDriverCaps")]
[StructLayout(LayoutKind.Sequential)]
public struct CAPDRIVERCAPS
{
/// <summary>Index of the capture driver. An index value can range from 0 to 9.</summary>
public uint wDeviceIndex;
/// <summary>Video-overlay flag. The value of this member is <c>TRUE</c> if the device supports video overlay.</summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fHasOverlay;
/// <summary>
/// Video source dialog flag. The value of this member is <c>TRUE</c> if the device supports a dialog box for selecting and
/// controlling the video source.
/// </summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fHasDlgVideoSource;
/// <summary>
/// Video format dialog flag. The value of this member is <c>TRUE</c> if the device supports a dialog box for selecting the
/// video format.
/// </summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fHasDlgVideoFormat;
/// <summary>
/// Video display dialog flag. The value of this member is <c>TRUE</c> if the device supports a dialog box for controlling the
/// redisplay of video from the capture frame buffer.
/// </summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fHasDlgVideoDisplay;
/// <summary>
/// Capture initialization flag. The value of this member is <c>TRUE</c> if a capture device has been successfully connected.
/// </summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fCaptureInitialized;
/// <summary>Driver palette flag. The value of this member is <c>TRUE</c> if the driver can create palettes.</summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fDriverSuppliesPalettes;
/// <summary>Not used in Win32 applications.</summary>
public HANDLE hVideoIn;
/// <summary>Not used in Win32 applications.</summary>
public HANDLE hVideoOut;
/// <summary>Not used in Win32 applications.</summary>
public HANDLE hVideoExtIn;
/// <summary>Not used in Win32 applications.</summary>
public HANDLE hVideoExtOut;
}
/// <summary>
/// The <c>CAPINFOCHUNK</c> structure contains parameters that can be used to define an information chunk within an AVI capture
/// file. The WM_CAP_FILE_SET_INFOCHUNK message or <c>capSetInfoChunk</c> macro is used to send a <c>CAPINFOCHUNK</c> structure to a
/// capture window.
/// </summary>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/ns-vfw-capinfochunk typedef struct tagCapInfoChunk { FOURCC fccInfoID;
// LPVOID lpData; LONG cbData; } CAPINFOCHUNK, *PCAPINFOCHUNK, *LPCAPINFOCHUNK;
[PInvokeData("vfw.h", MSDNShortId = "NS:vfw.tagCapInfoChunk")]
[StructLayout(LayoutKind.Sequential)]
public struct CAPINFOCHUNK
{
/// <summary>
/// Four-character code that identifies the representation of the chunk data. If this value is <c>NULL</c> and <c>lpData</c> is
/// <c>NULL</c>, all accumulated information chunks are deleted.
/// </summary>
public uint fccInfoID;
/// <summary>Pointer to the data. If this value is <c>NULL</c>, all <c>fccInfoID</c> information chunks are deleted.</summary>
public IntPtr lpData;
/// <summary>
/// Size, in bytes, of the data pointed to by <c>lpData</c>. If <c>lpData</c> specifies a null-terminated string, use the string
/// length incremented by one to save the <c>NULL</c> with the string.
/// </summary>
public int cbData;
}
/// <summary>The <c>CAPSTATUS</c> structure defines the current state of the capture window.</summary>
/// <remarks>
/// Because the state of a capture window changes in response to various messages, an application should update the information in
/// this structure whenever it needs to enable menu items, determine the actual state of the capture window, or call the video
/// format dialog box. If the application yields during streaming capture, this structure returns the progress of the capture in the
/// <c>dwCurrentVideoFrame</c>, <c>dwCurrentVideoFramesDropped</c>, dwCurre <c></c> ntWaveSamples, and <c>dwCurrentTimeElapsedMS</c>
/// members. Use the WM_CAP_GET_STATUS message or capGetStatus macro to update the contents of this structure.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/ns-vfw-capstatus typedef struct tagCapStatus { UINT uiImageWidth; UINT
// uiImageHeight; BOOL fLiveWindow; BOOL fOverlayWindow; BOOL fScale; POINT ptScroll; BOOL fUsingDefaultPalette; BOOL
// fAudioHardware; BOOL fCapFileExists; DWORD dwCurrentVideoFrame; DWORD dwCurrentVideoFramesDropped; DWORD dwCurrentWaveSamples;
// DWORD dwCurrentTimeElapsedMS; HPALETTE hPalCurrent; BOOL fCapturingNow; DWORD dwReturn; UINT wNumVideoAllocated; UINT
// wNumAudioAllocated; } CAPSTATUS, *PCAPSTATUS, *LPCAPSTATUS;
[PInvokeData("vfw.h", MSDNShortId = "NS:vfw.tagCapStatus")]
[StructLayout(LayoutKind.Sequential)]
public struct CAPSTATUS
{
/// <summary>Image width, in pixels.</summary>
public uint uiImageWidth;
/// <summary>Image height, in pixels</summary>
public uint uiImageHeight;
/// <summary>
/// Live window flag. The value of this member is <c>TRUE</c> if the window is displaying video using the preview method.
/// </summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fLiveWindow;
/// <summary>
/// Overlay window flag. The value of this member is <c>TRUE</c> if the window is displaying video using hardware overlay.
/// </summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fOverlayWindow;
/// <summary>
/// Input scaling flag. The value of this member is <c>TRUE</c> if the window is scaling the input video to the client area when
/// displaying video using preview. This parameter has no effect when displaying video using overlay.
/// </summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fScale;
/// <summary>The x- and y-offset of the pixel displayed in the upper left corner of the client area of the window.</summary>
public POINT ptScroll;
/// <summary>Default palette flag. The value of this member is <c>TRUE</c> if the capture driver is using its default palette.</summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fUsingDefaultPalette;
/// <summary>Audio hardware flag. The value of this member is <c>TRUE</c> if the system has waveform-audio hardware installed.</summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fAudioHardware;
/// <summary>Capture file flag. The value of this member is <c>TRUE</c> if a valid capture file has been generated.</summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fCapFileExists;
/// <summary>
/// Number of frames processed during the current (or most recent) streaming capture. This count includes dropped frames.
/// </summary>
public uint dwCurrentVideoFrame;
/// <summary>
/// Number of frames dropped during the current (or most recent) streaming capture. Dropped frames occur when the capture rate
/// exceeds the rate at which frames can be saved to file. In this case, the capture driver has no buffers available for storing
/// data. Dropping frames does not affect synchronization because the previous frame is displayed in place of the dropped frame.
/// </summary>
public uint dwCurrentVideoFramesDropped;
/// <summary>Number of waveform-audio samples processed during the current (or most recent) streaming capture.</summary>
public uint dwCurrentWaveSamples;
/// <summary>Time, in milliseconds, since the start of the current (or most recent) streaming capture.</summary>
public uint dwCurrentTimeElapsedMS;
/// <summary>Handle to current palette.</summary>
public HPALETTE hPalCurrent;
/// <summary>Capturing flag. The value of this member is <c>TRUE</c> when capturing is in progress.</summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fCapturingNow;
/// <summary>Error return values. Use this member if your application does not support an error callback function.</summary>
public uint dwReturn;
/// <summary>
/// Number of video buffers allocated. This value might be less than the number specified in the <c>wNumVideoRequested</c>
/// member of the CAPTUREPARMS structure.
/// </summary>
public uint wNumVideoAllocated;
/// <summary>
/// Number of audio buffers allocated. This value might be less than the number specified in the <c>wNumAudioRequested</c>
/// member of the CAPTUREPARMS structure.
/// </summary>
public uint wNumAudioAllocated;
}
/// <summary>
/// The <c>CAPTUREPARMS</c> structure contains parameters that control the streaming video capture process. This structure is used
/// to get and set parameters that affect the capture rate, the number of buffers to use while capturing, and how capture is terminated.
/// </summary>
/// <remarks>
/// <para>
/// The WM_CAP_GET_SEQUENCE_SETUP message or capCaptureGetSetup macro is used to retrieve the current capture parameters. The
/// WM_CAP_SET_SEQUENCE_SETUP message or capCaptureSetSetup macro is used to set the capture parameters.
/// </para>
/// <para>
/// The WM_CAP_GET_SEQUENCE_SETUP message or capCaptureGetSetup macro is used to retrieve the current capture parameters. The
/// WM_CAP_SET_SEQUENCE_SETUP message or capCaptureSetSetup macro is used to set the capture parameters.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/ns-vfw-captureparms typedef struct tagCaptureParms { DWORD
// dwRequestMicroSecPerFrame; BOOL fMakeUserHitOKToCapture; UINT wPercentDropForError; BOOL fYield; DWORD dwIndexSize; UINT
// wChunkGranularity; BOOL fUsingDOSMemory; UINT wNumVideoRequested; BOOL fCaptureAudio; UINT wNumAudioRequested; UINT vKeyAbort;
// BOOL fAbortLeftMouse; BOOL fAbortRightMouse; BOOL fLimitEnabled; UINT wTimeLimit; BOOL fMCIControl; BOOL fStepMCIDevice; DWORD
// dwMCIStartTime; DWORD dwMCIStopTime; BOOL fStepCaptureAt2x; UINT wStepCaptureAverageFrames; DWORD dwAudioBufferSize; BOOL
// fDisableWriteCache; UINT AVStreamMaster; } CAPTUREPARMS, *PCAPTUREPARMS, *LPCAPTUREPARMS;
[PInvokeData("vfw.h", MSDNShortId = "NS:vfw.tagCaptureParms")]
[StructLayout(LayoutKind.Sequential)]
public struct CAPTUREPARMS
{
/// <summary>Requested frame rate, in microseconds. The default value is 66667, which corresponds to 15 frames per second.</summary>
public uint dwRequestMicroSecPerFrame;
/// <summary>
/// User-initiated capture flag. If this member is <c>TRUE</c>, AVICap displays a dialog box prompting the user to initiate
/// capture. The default value is <c>FALSE</c>.
/// </summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fMakeUserHitOKToCapture;
/// <summary>
/// Maximum allowable percentage of dropped frames during capture. Values range from 0 to 100. The default value is 10.
/// </summary>
public uint wPercentDropForError;
/// <summary>
/// <para>
/// Yield flag. If this member is <c>TRUE</c>, the capture window spawns a separate background thread to perform step and
/// streaming capture. The default value is <c>FALSE</c>.
/// </para>
/// <para>
/// Applications that set this flag must handle potential reentry issues because the controls in the application are not
/// disabled while capture is in progress.
/// </para>
/// </summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fYield;
/// <summary>
/// <para>
/// Maximum number of index entries in an AVI file. Values range from 1800 to 324,000. If set to 0, a default value of 34,952
/// (32K frames plus a proportional number of audio buffers) is used.
/// </para>
/// <para>
/// Each video frame or buffer of waveform-audio data uses one index entry. The value of this entry establishes a limit for the
/// number of frames or audio buffers that can be captured.
/// </para>
/// </summary>
public uint dwIndexSize;
/// <summary>Logical block size, in bytes, of an AVI file. The value 0 indicates the current sector size is used as the granularity.</summary>
public uint wChunkGranularity;
/// <summary>Not used in Win32 applications.</summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fUsingDOSMemory;
/// <summary>
/// Maximum number of video buffers to allocate. The memory area to place the buffers is specified with <c>fUsingDOSMemory</c>.
/// The actual number of buffers allocated might be lower if memory is unavailable.
/// </summary>
public uint wNumVideoRequested;
/// <summary>
/// Capture audio flag. If this member is <c>TRUE</c>, audio is captured during streaming capture. This is the default value if
/// audio hardware is installed.
/// </summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fCaptureAudio;
/// <summary>Maximum number of audio buffers to allocate. The maximum number of buffers is 10.</summary>
public uint wNumAudioRequested;
/// <summary>
/// <para>
/// Virtual keycode used to terminate streaming capture. The default value is VK_ESCAPE. You must call the RegisterHotKey
/// function before specifying a keystroke that can abort a capture session.
/// </para>
/// <para>
/// You can combine keycodes that include CTRL and SHIFT keystrokes by using the logical OR operator with the keycodes for CTRL
/// (0x8000) and SHIFT (0x4000).
/// </para>
/// </summary>
public uint vKeyAbort;
/// <summary>
/// Abort flag for left mouse button. If this member is <c>TRUE</c>, streaming capture stops if the left mouse button is
/// pressed. The default value is <c>TRUE</c>.
/// </summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fAbortLeftMouse;
/// <summary>
/// Abort flag for right mouse button. If this member is <c>TRUE</c>, streaming capture stops if the right mouse button is
/// pressed. The default value is <c>TRUE</c>.
/// </summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fAbortRightMouse;
/// <summary>
/// Time limit enabled flag. If this member is <c>TRUE</c>, streaming capture stops after the number of seconds in
/// <c>wTimeLimit</c> has elapsed. The default value is <c>FALSE</c>.
/// </summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fLimitEnabled;
/// <summary>Time limit for capture, in seconds. This parameter is used only if <c>fLimitEnabled</c> is <c>TRUE</c>.</summary>
public uint wTimeLimit;
/// <summary>
/// MCI device capture flag. If this member is <c>TRUE</c>, AVICap controls an MCI-compatible video source during streaming
/// capture. MCI-compatible video sources include VCRs and laserdiscs.
/// </summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fMCIControl;
/// <summary>
/// MCI device step capture flag. If this member is <c>TRUE</c>, step capture using an MCI device as a video source is enabled.
/// If it is <c>FALSE</c>, real-time capture using an MCI device is enabled. (If <c>fMCIControl</c> is <c>FALSE</c>, this member
/// is ignored.)
/// </summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fStepMCIDevice;
/// <summary>
/// Starting position, in milliseconds, of the MCI device for the capture sequence. (If <c>fMCIControl</c> is <c>FALSE</c>, this
/// member is ignored.)
/// </summary>
public uint dwMCIStartTime;
/// <summary>
/// Stopping position, in milliseconds, of the MCI device for the capture sequence. When this position in the content is
/// reached, capture ends and the MCI device stops. (If <c>fMCIControl</c> is <c>FALSE</c>, this member is ignored.)
/// </summary>
public uint dwMCIStopTime;
/// <summary>
/// <para>
/// Double-resolution step capture flag. If this member is <c>TRUE</c>, the capture hardware captures at twice the specified
/// resolution. (The resolution for the height and width is doubled.)
/// </para>
/// <para>Enable this option if the hardware does not support hardware-based decimation and you are capturing in the RGB format.</para>
/// </summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fStepCaptureAt2x;
/// <summary>
/// Number of times a frame is sampled when creating a frame based on the average sample. A typical value for the number of
/// averages is 5.
/// </summary>
public uint wStepCaptureAverageFrames;
/// <summary>
/// Audio buffer size. If the default value of zero is used, the size of each buffer will be the maximum of 0.5 seconds of audio
/// or 10K bytes.
/// </summary>
public uint dwAudioBufferSize;
/// <summary>Not used in Win32 applications.</summary>
[MarshalAs(UnmanagedType.Bool)]
public bool fDisableWriteCache;
/// <summary>
/// Indicates whether the audio stream controls the clock when writing an AVI file. If this member is set to
/// AVSTREAMMASTER_AUDIO, the audio stream is considered the master stream and the video stream duration is forced to match the
/// audio duration. If this member is set to AVSTREAMMASTER_NONE, the durations of audio and video streams can differ.
/// </summary>
public uint AVStreamMaster;
}
/// <summary>The <c>VIDEOHDR</c> structure is used by the capVideoStreamCallback function.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/vfw/ns-vfw-videohdr typedef struct videohdr_tag { LPBYTE lpData; DWORD
// dwBufferLength; DWORD dwBytesUsed; DWORD dwTimeCaptured; DWORD_PTR dwUser; DWORD dwFlags; DWORD_PTR dwReserved[4]; } VIDEOHDR,
// *PVIDEOHDR, *LPVIDEOHDR;
[PInvokeData("vfw.h", MSDNShortId = "NS:vfw.videohdr_tag")]
[StructLayout(LayoutKind.Sequential)]
public struct VIDEOHDR
{
/// <summary>Pointer to locked data buffer.</summary>
public IntPtr lpData;
/// <summary>Length of data buffer.</summary>
public uint dwBufferLength;
/// <summary>Bytes actually used.</summary>
public uint dwBytesUsed;
/// <summary>Milliseconds from start of stream.</summary>
public uint dwTimeCaptured;
/// <summary>User-defined data.</summary>
public IntPtr dwUser;
/// <summary>
/// <para>The flags are defined as follows.</para>
/// <list type="table">
/// <listheader>
/// <term>Flag</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>VHDR_DONE</term>
/// <term>Done bit</term>
/// </item>
/// <item>
/// <term>VHDR_PREPARED</term>
/// <term>Set if this header has been prepared</term>
/// </item>
/// <item>
/// <term>VHDR_INQUEUE</term>
/// <term>Reserved for driver</term>
/// </item>
/// <item>
/// <term>VHDR_KEYFRAME</term>
/// <term>Key Frame</term>
/// </item>
/// </list>
/// </summary>
public VHDR dwFlags;
/// <summary>Reserved for driver.</summary>
public IntPtr dwReserved1;
/// <summary>Reserved for driver.</summary>
public IntPtr dwReserved2;
/// <summary>Reserved for driver.</summary>
public IntPtr dwReserved3;
/// <summary>Reserved for driver.</summary>
public IntPtr dwReserved4;
}
}
}
Reference in New Issue View Git Blame Copy Permalink