c# 获取 摄像头 实现录像

最新推荐文章于 2024-02-24 10:33:44 发布
最新推荐文章于 2024-02-24 10:33:44 发布
阅读量9.2k 收藏 18
点赞数 1
分类专栏： WPF/Winform 机械控制 文章标签： c# 摄像头 VFW webcam

c# 获取 摄像头 实现录像 

      利用普通的简易摄像头，通过C#语言即可开发成简易视频程序。本实例利用市场上购买的普通摄像头，利用VFW技术，实现单路视频监控系统。运行程序，窗体中将显示舰体摄像头采集的视频信息。如图13.9所示。
技术要点
本实例主要使用了VFW（Video for Windows）技术。VFW 是Microsoft公司为开发Windows平台下的视频应用程序提供的软件工具包，提供了一系列应用程序编程接口（API），用户可以通过这些接口很方便地实现视频捕获、视频编辑及视频播放等通用功能，还可利用回调函数开发比较复杂的视频应用程序。该技术的特点是播放视频时不需要专用的硬件设备，而且应用灵活，可以满足视频应用程序开发的需要。Windows操作系统自身就携带了VFW技术，系统安装时，会自动安装VFW的相关组件。
VFW技术主要由六个功能模块组成，下面进行简单说明。
     AVICAP32.DLL：包含执行视频捕获的函数，给AVI文件的I/O处理和视频，音频设备驱动程序提供一个高级接口。
     MSVIDEO.DLL：包含一套特殊的DrawDib函数，用来处理程序上的视频操作。
    MCIAVI.DRV：包括对VFW的MCI命令解释器的驱动程序。
    AVIFILE.DLL：包含由标准多媒体I/O（mmio）函数提供的更高级的命令，用来访问.AVI文件。
    ICM：压缩管理器，用于管理的视频压缩/解压缩的编译码器。
    ACM：音频压缩管理器，提供与ICM相似的服务，适用于波形音频。
AVICAP32.DLL中的函数和USER32.DLL中的函数，函数语法及结构如下。
（1）capCreateCaptureWindow函数
该函数用于创建一个视频捕捉窗口。语法如下：
        [DllImport("avicap32.dll")]
        public static extern IntPtr capCreateCaptureWindowA(byte[] lpszWindowName, int dwStyle, int x, int y, int nWidth, int nHeight, IntPtr hWndParent, int nID);
参数说明如下。
     lpszWindowName：标识窗口的名称。
     dwStyle：标识窗口风格。
     x、y：标识窗口的左上角坐标。
     nWidth、nHeight：标识窗口的宽度和高度。
     hWnd：标识父窗口句柄。
     nID：标识窗口ID。
     返回值：视频捕捉窗口句柄。
（2）SendMessage函数
用于向Windows系统发送消息机制。
[DllImport("User32.dll")]
private static extern bool SendMessage(IntPtr hWnd, int wMsg, int wParam, int lParam);
参数说明如下。
     hWnd：窗口句柄。
     wMsg：将要发送的消息。
     wParam、lParam：消息的参数，每个消息都有两个参数，参数设置由发送的消息而定。

 

Form1窗体中通过调用视频类中的方法来实现相应的功能。
在【开始录像】按钮的Click事件中添加如下代码：
        private void buttonStart_Click(object sender, EventArgs e)
        {
            buttonStart.Enabled = false;
            buttonStop.Enabled = true;
            //btnPz.Enabled = true;
            video = new cVideo(picCapture.Handle, picCapture.Width, picCapture.Height);
            video.StartWebCam();
        }
在【停止录像】按钮的Click事件中添加如下代码：
        private void buttonStop_Click(object sender, EventArgs e)
        {
            buttonStart.Enabled = true;
            buttonStop.Enabled = false;
            buttonPz.Enabled = false;
            video.CloseWebcam();
        }
在【拍照】按钮的Click事件下添加如下代码：
        private void buttonPz_Click(object sender, EventArgs e)
        {
            video.GrabImage(picCapture.Handle, "d:\\a.bmp");
        }
 
完整代码如下：
1、Program.cs
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
namespace Video1
{
    static class Program
    {
        /// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());
        }
    }
}
 
2、Form1.cs
 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace Video1
{
    public partial class Form1 : Form
    {
        cVideo video;
        public Form1()
        {
            InitializeComponent();
        }
        private void buttonStart_Click(object sender, EventArgs e)
        {
            buttonStart.Enabled = false;
            buttonStop.Enabled = true;
            //btnPz.Enabled = true;
            video = new cVideo(picCapture.Handle, picCapture.Width, picCapture.Height);
            video.StartWebCam();
        }
        private void buttonStop_Click(object sender, EventArgs e)
        {
            buttonStart.Enabled = true;
            buttonStop.Enabled = false;
            buttonPz.Enabled = false;
            video.CloseWebcam();
        }
        private void buttonPz_Click(object sender, EventArgs e)
        {
            video.GrabImage(picCapture.Handle, "d:\\a.bmp");
        }
    }
}
3、Form1.Designer.cs
 
namespace Video1
{
    partial class Form1
    {
        /// <summary>
        /// 必需的设计器变量。
        /// </summary>
        private System.ComponentModel.IContainer components = null;
        /// <summary>
        /// 清理所有正在使用的资源。
        /// </summary>
        /// <param>如果应释放托管资源，为 true；否则为 false。</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }
        #region Windows 窗体设计器生成的代码
        /// <summary>
        /// 设计器支持所需的方法 - 不要
        /// 使用代码编辑器修改此方法的内容。
        /// </summary>
        private void InitializeComponent()
        {
            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Form1));
            this.buttonStart = new System.Windows.Forms.Button();
            this.buttonStop = new System.Windows.Forms.Button();
            this.buttonPz = new System.Windows.Forms.Button();
            this.panelTop = new System.Windows.Forms.Panel();
            this.picCapture = new System.Windows.Forms.PictureBox();
            this.panelBottom = new System.Windows.Forms.Panel();
            this.panelTop.SuspendLayout();
            ((System.ComponentModel.ISupportInitialize)(this.picCapture)).BeginInit();
            this.panelBottom.SuspendLayout();
            this.SuspendLayout();
            // 
            // buttonStart
            // 
            this.buttonStart.Location = new System.Drawing.Point(39, 3);
            this.buttonStart.Name = "buttonStart";
            this.buttonStart.Size = new System.Drawing.Size(88, 36);
            this.buttonStart.TabIndex = 1;
            this.buttonStart.Text = "开始录像";
            this.buttonStart.UseVisualStyleBackColor = true;
            this.buttonStart.Click += new System.EventHandler(this.buttonStart_Click);
            // 
            // buttonStop
            // 
            this.buttonStop.Location = new System.Drawing.Point(181, 3);
            this.buttonStop.Name = "buttonStop";
            this.buttonStop.Size = new System.Drawing.Size(80, 36);
            this.buttonStop.TabIndex = 2;
            this.buttonStop.Text = "停止录像";
            this.buttonStop.UseVisualStyleBackColor = true;
            this.buttonStop.Click += new System.EventHandler(this.buttonStop_Click);
            // 
            // buttonPz
            // 
            this.buttonPz.Location = new System.Drawing.Point(313, 3);
            this.buttonPz.Name = "buttonPz";
            this.buttonPz.Size = new System.Drawing.Size(77, 36);
            this.buttonPz.TabIndex = 3;
            this.buttonPz.Text = "拍  照";
            this.buttonPz.UseVisualStyleBackColor = true;
            this.buttonPz.Click += new System.EventHandler(this.buttonPz_Click);
            // 
            // panelTop
            // 
            this.panelTop.AutoSize = true;
            this.panelTop.Controls.Add(this.picCapture);
            this.panelTop.Dock = System.Windows.Forms.DockStyle.Fill;
            this.panelTop.Location = new System.Drawing.Point(0, 0);
            this.panelTop.Name = "panelTop";
            this.panelTop.Size = new System.Drawing.Size(468, 372);
            this.panelTop.TabIndex = 4;
            // 
            // picCapture
            // 
            this.picCapture.Dock = System.Windows.Forms.DockStyle.Fill;
            this.picCapture.InitialImage = ((System.Drawing.Image)(resources.GetObject("picCapture.InitialImage")));
            this.picCapture.Location = new System.Drawing.Point(0, 0);
            this.picCapture.Name = "picCapture";
            this.picCapture.Size = new System.Drawing.Size(468, 372);
            this.picCapture.TabIndex = 0;
            this.picCapture.TabStop = false;
            // 
            // panelBottom
            // 
            this.panelBottom.Controls.Add(this.buttonStart);
            this.panelBottom.Controls.Add(this.buttonStop);
            this.panelBottom.Controls.Add(this.buttonPz);
            this.panelBottom.Dock = System.Windows.Forms.DockStyle.Bottom;
            this.panelBottom.Location = new System.Drawing.Point(0, 327);
            this.panelBottom.Name = "panelBottom";
            this.panelBottom.Size = new System.Drawing.Size(468, 45);
            this.panelBottom.TabIndex = 5;
            // 
            // Form1
            // 
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 12F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(468, 372);
            this.Controls.Add(this.panelBottom);
            this.Controls.Add(this.panelTop);
            this.Name = "Form1";
            this.Text = "Form1";
            this.panelTop.ResumeLayout(false);
            ((System.ComponentModel.ISupportInitialize)(this.picCapture)).EndInit();
            this.panelBottom.ResumeLayout(false);
            this.ResumeLayout(false);
            this.PerformLayout();
        }
        #endregion
        private System.Windows.Forms.PictureBox picCapture;
        private System.Windows.Forms.Button buttonStart;
        private System.Windows.Forms.Button buttonStop;
        private System.Windows.Forms.Button buttonPz;
        private System.Windows.Forms.Panel panelTop;
        private System.Windows.Forms.Panel panelBottom;
    }
}
4、ClassVideoAPI.cs
 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows.Forms;
using System.IO;
namespace Video1
{
    public class VideoAPI  //视频API类
    {
        //  视频ＡＰＩ调用
        [DllImport("avicap32.dll")]//包含了执行视频捕获的函数，它给AVI文件I/O和视频、音频设备驱动程序提供一个高级接口
        public static extern IntPtr capCreateCaptureWindow(string lpszWindowName, int dwStyle, int x, int y, int nWidth, int nHeight, IntPtr hwndParent, int nID);
        [DllImport("AVICAP32.dll", CharSet = CharSet.Unicode)]
        public static extern bool capGetDriverDescription(int wDriverIndex, StringBuilder lpszName, int cbName, StringBuilder lpszVer, int cbVer);
        [DllImport("avicap32.dll")]
        public static extern IntPtr capCreateCaptureWindowA(byte[] lpszWindowName, int dwStyle, int x, int y, int nWidth, int nHeight, IntPtr hWndParent, int nID);
        [DllImport("avicap32.dll")]
        public static extern bool capGetDriverDescriptionA(short wDriver, byte[] lpszName, int cbName, byte[] lpszVer, int cbVer);
        [DllImport("User32.dll")]
        public static extern bool SendMessage(IntPtr hWnd, int wMsg, bool wParam, int lParam);
        [DllImport("User32.dll")]
        public static extern bool SendMessage(IntPtr hWnd, int wMsg, short wParam, int lParam);
        [DllImport("User32.dll")]
        public static extern bool SendMessage(IntPtr hWnd, int wMsg, int wParam, int lParam);
        [DllImport("User32.dll")]
        public static extern bool SendMessage(IntPtr hWnd, int wMsg, short wParam, FrameEventHandler lParam);
        [DllImport("User32.dll")]
        public static extern bool SendMessage(IntPtr hWnd, int wMsg, int wParam, ref BITMAPINFO lParam);
        [DllImport("User32.dll")]
        public static extern bool SendMessage(IntPtr hWnd, int wMsg, int wParam, ref CAPDRIVERCAPS lParam);
        [DllImport("User32.dll")]
        public static extern bool SendMessage(IntPtr hWnd, int wMsg, int wParam, ref CAPTUREPARMS lParam);
        [DllImport("User32.dll")]
        public static extern bool SendMessage(IntPtr hWnd, int wMsg, int wParam, ref CAPSTATUS lParam);
        [DllImport("User32.dll")]
        public static extern int SetWindowPos(IntPtr hWnd, int hWndInsertAfter, int x, int y, int cx, int cy, int wFlags);
        [DllImport("avicap32.dll")]
        public static extern int capGetVideoFormat(IntPtr hWnd, IntPtr psVideoFormat, int wSize);
        //  常量
        // public const int WM_USER = 0x400;
        public const int WS_CHILD = 0x40000000;
        public const int WS_VISIBLE = 0x10000000;
        public const int SWP_NOMOVE = 0x2;
        public const int SWP_NOZORDER = 0x4;
        // public const int WM_CAP_DRIVER_CONNECT = WM_USER + 10;
        //   public const int WM_CAP_DRIVER_DISCONNECT = WM_USER + 11;
        public const int WM_CAP_SET_CALLBACK_FRAME = WM_USER + 5;
        //   public const int WM_CAP_SET_PREVIEW = WM_USER + 50;
        //  public const int WM_CAP_SET_PREVIEWRATE = WM_USER + 52;
        //  public const int WM_CAP_SET_VIDEOFORMAT = WM_USER + 45;
        //   public const int WM_CAP_START = WM_USER;
        public const int WM_CAP_SAVEDIB = WM_CAP_START + 25;
        public const string avicap32 = "avicap32.dll";
        public const int WM_USER = 1024;
        /// <summary>
        ///WM_CAP_START=WM_USER=1024
        /// </summary>
        public const int WM_CAP_START = WM_USER;
        // start of unicode messages
        /// <summary>
        /// 开始   WM_USER + 100=1124
        /// </summary>
        public const int WM_CAP_UNICODE_START = WM_USER + 100; //开始   1124
        /// <summary>
        /// /获得 CAPSTR EAMPTR   
        /// WM_CAP_START + 1=1025
        /// </summary>
        public const int WM_CAP_GET_CAPSTREAMPTR = (WM_CAP_START + 1); //获得 CAPSTR EAMPTR
        /// <summary>
        /// 设置收回错误   WM_CAP_START + 2=1026
        /// </summary>
        public const int WM_CAP_SET_CALLBACK_ERROR = (WM_CAP_START + 2); //设置收回错误
        /// <summary>
        /// 设置收回状态 WM_CAP_START + 3=1027
        /// </summary>
        public const int WM_CAP_SET_CALLBACK_STATUS = (WM_CAP_START + 3); //设置收回状态
        /// <summary>
        /// 设置收回出产  WM_CAP_START + 4=1028
        /// </summary>
        public const int WM_CAP_SET_CALLBACK_YIELD = (WM_CAP_START + 4); //设置收回出产
        /// <summary>
        /// 设置收回结构  WM_CAP_START + 5=1029
        /// </summary>
        public const int WM_CAP_SET_CALLBACK_FRame = (WM_CAP_START + 5); //设置收回结构
        /// <summary>
        /// 设置收回视频流  WM_CAP_START + 6=1030
        /// </summary>
        public const int WM_CAP_SET_CALLBACK_VIDEOSTREAM = (WM_CAP_START + 6); //设置收回视频流
        /// <summary>
        /// 设置收回视频波流  WM_CAP_START +7=1031
        /// </summary>
        public const int WM_CAP_SET_CALLBACK_WAVESTREAM = (WM_CAP_START + 7); //设置收回视频波流
        /// <summary>
        /// 获得使用者数据 WM_CAP_START + 8=1032
        /// </summary>
        public const int WM_CAP_GET_USER_DATA = (WM_CAP_START + 8); //获得使用者数据
        /// <summary>
        /// 设置使用者数据 WM_CAP_START + 9=1033
        /// </summary>
        public const int WM_CAP_SET_USER_DATA = (WM_CAP_START + 9); //设置使用者数据
        /// <summary>
        /// 驱动程序连接  WM_CAP_START + 10=1034
        /// </summary>
        public const int WM_CAP_DRIVER_CONNECT = (WM_CAP_START + 10); //驱动程序连接
        /// <summary>
        /// 断开启动程序连接 WM_CAP_START + 11=1035
        /// </summary>
        public const int WM_CAP_DRIVER_DISCONNECT = (WM_CAP_START + 11); //断开启动程序连接
        /// <summary>
        /// 获得驱动程序名字 WM_CAP_START + 12=1036
        /// </summary>
        public const int WM_CAP_DRIVER_GET_NAME = (WM_CAP_START + 12); //获得驱动程序名字
        /// <summary>
        /// 获得驱动程序版本 WM_CAP_START + 13=1037
        /// </summary>
        public const int WM_CAP_DRIVER_GET_VERSION = (WM_CAP_START + 13); //获得驱动程序版本
        /// <summary>
        /// 获得驱动程序帽子 WM_CAP_START + 14=1038
        /// </summary>
        public const int WM_CAP_DRIVER_GET_CAPS = (WM_CAP_START + 14); //获得驱动程序帽子
        /// <summary>
        /// 设置捕获文件 WM_CAP_START + 20=1044
        /// </summary>
        public const int WM_CAP_FILE_SET_CAPTURE_FILE = (WM_CAP_START + 20); //设置捕获文件
        /// <summary>
        /// 获得捕获文件 WM_CAP_START + 21=1045
        /// </summary>
        public const int WM_CAP_FILE_GET_CAPTURE_FILE = (WM_CAP_START + 21); //获得捕获文件
        /// <summary>
        /// 另存文件为  WM_CAP_START + 23=1047
        /// </summary>
        public const int WM_CAP_FILE_SAVEAS = (WM_CAP_START + 23); //另存文件为
        /// <summary>
        /// 保存文件    WM_CAP_START + 25=1049
        /// </summary>
        public const int WM_CAP_FILE_SAVEDIB = (WM_CAP_START + 25); //保存文件
        // out of order to save on ifdefs
        /// <summary>
        /// 分派文件  WM_CAP_START + 22=1044
        /// </summary>
        public const int WM_CAP_FILE_ALLOCATE = (WM_CAP_START + 22); //分派文件
        /// <summary>
        /// 设置开始文件  WM_CAP_START + 24=1046
        /// </summary>
        public const int WM_CAP_FILE_SET_INFOCHUNK = (WM_CAP_START + 24); //设置开始文件
        /// <summary>
        /// 编辑复制   WM_CAP_START + 30=1054
        /// </summary>
        public const int WM_CAP_EDIT_COPY = (WM_CAP_START + 30); //编辑复制
        /// <summary>
        /// 设置音频格式  WM_CAP_START + 35=1059
        /// </summary>
        public const int WM_CAP_SET_AUDIOFORMAT = (WM_CAP_START + 35); //设置音频格式
        /// <summary>
        /// 捕获音频格式  WM_CAP_START + 36=1060
        /// </summary>
        public const int WM_CAP_GET_AUDIOFORMAT = (WM_CAP_START + 36); //捕获音频格式
        /// <summary>
        /// 打开视频格式设置对话框  WM_CAP_START + 41=1065
        /// </summary>
        public const int WM_CAP_DLG_VIDEOFORMAT = (WM_CAP_START + 41); //1065 打开视频格式设置对话框
        /// <summary>
        /// 打开属性设置对话框，设置对比度、亮度等   WM_CAP_START + 42=1066
        /// </summary>
        public const int WM_CAP_DLG_VIDEOSOURCE = (WM_CAP_START + 42); //1066 打开属性设置对话框，设置对比度、亮度等。
        /// <summary>
        /// 打开视频显示 WM_CAP_START + 43=1067
        /// </summary>
        public const int WM_CAP_DLG_VIDEODISPLAY = (WM_CAP_START + 43); //1067 打开视频显示
        /// <summary>
        /// 获得视频格式 WM_CAP_START + 44=1068
        /// </summary>
        public const int WM_CAP_GET_VIDEOFORMAT = (WM_CAP_START + 44); //1068 获得视频格式
        /// <summary>
        /// 设置视频格式 WM_CAP_START + 45=1069
        /// </summary>
        public const int WM_CAP_SET_VIDEOFORMAT = (WM_CAP_START + 45); //1069 设置视频格式
        /// <summary>
        /// 打开压缩设置对话框 WM_CAP_START + 46=1070
        /// </summary>
        public const int WM_CAP_DLG_VIDEOCOMPRESSION = (WM_CAP_START + 46); //1070 打开压缩设置对话框
        /// <summary>
        /// 设置预览 WM_CAP_START + 50=1074
        /// </summary>
        public const int WM_CAP_SET_PREVIEW = (WM_CAP_START + 50); //设置预览
        /// <summary>
        /// 设置覆盖 WM_CAP_START + 51=1075
        /// </summary>
        public const int WM_CAP_SET_OVERLAY = (WM_CAP_START + 51); //设置覆盖
        /// <summary>
        /// 设置预览比例 WM_CAP_START + 52=1076
        /// </summary>
        public const int WM_CAP_SET_PREVIEWRATE = (WM_CAP_START + 52); //设置预览比例
        /// <summary>
        /// 设置刻度 WM_CAP_START + 53=1077
        /// </summary>
        public const int WM_CAP_SET_SCALE = (WM_CAP_START + 53); //设置刻度
        /// <summary> 
        /// 获得状态 WM_CAP_START + 54=1078
        /// </summary>
        public const int WM_CAP_GET_STATUS = (WM_CAP_START + 54); //获得状态
        /// <summary>
        /// 设置卷 WM_CAP_START + 55=1079
        /// </summary>
        public const int WM_CAP_SET_SCROLL = (WM_CAP_START + 55); //设置卷
        /// <summary>
        /// 逮捕结构 WM_CAP_START + 60=1084
        /// </summary>
        public const int WM_CAP_GRAB_FRame = (WM_CAP_START + 60); //逮捕结构
        /// <summary>
        /// 停止逮捕结构 WM_CAP_START + 61=1085
        /// </summary>
        public const int WM_CAP_GRAB_FRame_NOSTOP = (WM_CAP_START + 61); //停止逮捕结构
        /// <summary>
        /// 次序 WM_CAP_START + 62=1086
        /// </summary>
        public const int WM_CAP_SEQUENCE = (WM_CAP_START + 62); //次序
        /// <summary>
        /// 没有文件 WM_CAP_START + 63=1087
        /// </summary>
        public const int WM_CAP_SEQUENCE_NOFILE = (WM_CAP_START + 63); //没有文件
        /// <summary>
        /// 设置安装次序 WM_CAP_START + 64=1088
        /// </summary>
        public const int WM_CAP_SET_SEQUENCE_SETUP = (WM_CAP_START + 64); //设置安装次序
        /// <summary>
        /// 获得安装次序 WM_CAP_START + 65=1089
        /// </summary>
        public const int WM_CAP_GET_SEQUENCE_SETUP = (WM_CAP_START + 65); //获得安装次序
        /// <summary>
        /// 设置媒体控制接口 WM_CAP_START + 66=1090
        /// </summary>
        public const int WM_CAP_SET_MCI_DEVICE = (WM_CAP_START + 66); //设置媒体控制接口
        /// <summary>
        /// 获得媒体控制接口 WM_CAP_START + 67=1091
        /// </summary>
        public const int WM_CAP_GET_MCI_DEVICE = (WM_CAP_START + 67); //获得媒体控制接口 
        /// <summary>
        /// 停止 WM_CAP_START + 68=1092
        /// </summary>
        public const int WM_CAP_STOP = (WM_CAP_START + 68); //停止
        /// <summary>
        /// 异常中断 WM_CAP_START + 69=1093
        /// </summary>
        public const int WM_CAP_ABORT = (WM_CAP_START + 69); //异常中断
        /// <summary>
        /// 打开单一的结构 WM_CAP_START + 68=1094
        /// </summary>
        public const int WM_CAP_SINGLE_FRame_OPEN = (WM_CAP_START + 70); //打开单一的结构
        /// <summary>
        /// 关闭单一的结构 WM_CAP_START + 71=1095
        /// </summary>
        public const int WM_CAP_SINGLE_FRame_CLOSE = (WM_CAP_START + 71); //关闭单一的结构
        /// <summary>
        /// 单一的结构 WM_CAP_START + 72=1096
        /// </summary>
        public const int WM_CAP_SINGLE_FRame = (WM_CAP_START + 72); //单一的结构
        /// <summary>
        /// 打开视频 WM_CAP_START + 80=1104
        /// </summary>
        public const int WM_CAP_PAL_OPEN = (WM_CAP_START + 80); //打开视频
        /// <summary>
        /// 保存视频 WM_CAP_START + 81=1105
        /// </summary>
        public const int WM_CAP_PAL_SAVE = (WM_CAP_START + 81); //保存视频
        /// <summary>
        /// 粘贴视频 WM_CAP_START + 82=1106
        /// </summary>
        public const int WM_CAP_PAL_PASTE = (WM_CAP_START + 82); //粘贴视频
        /// <summary>
        /// 自动创造 WM_CAP_START + 83=1107
        /// </summary>
        public const int WM_CAP_PAL_AUTOCREATE = (WM_CAP_START + 83); //自动创造
        /// <summary>
        /// 手动创造 WM_CAP_START + 84=1108
        /// </summary>
        public const int WM_CAP_PAL_MANUALCREATE = (WM_CAP_START + 84); //手动创造
        // Following added post VFW 1.1
        /// <summary>
        /// 设置收回的错误 WM_CAP_START + 85=1109
        /// </summary>
        public const int WM_CAP_SET_CALLBACK_CAPCONTROL = (WM_CAP_START + 85); // 设置收回的错误
        public const int WM_CAP_END = WM_CAP_SET_CALLBACK_CAPCONTROL;
        public delegate void FrameEventHandler(IntPtr lwnd, IntPtr lpVHdr);
        #region 公共函数
        //公共函数
        public static object GetStructure(IntPtr ptr, ValueType structure)
        {
            return Marshal.PtrToStructure(ptr, structure.GetType());
        }
        public static object GetStructure(int ptr, ValueType structure)
        {
            return GetStructure(new IntPtr(ptr), structure);
        }
        public static void Copy(IntPtr ptr, byte[] data)
        {
            Marshal.Copy(ptr, data, 0, data.Length);
        }
        public static void Copy(int ptr, byte[] data)
        {
            Copy(new IntPtr(ptr), data);
        }
        public static int SizeOf(object structure)
        {
            return Marshal.SizeOf(structure);
        }
        #endregion 公共函数
        #region 结构 VIDEOHDR|BITMAPINFOHEADER|BITMAPINFO|CAPTUREPARMS|CAPDRIVERCAPS|CAPSTATUS
        //========================================================VideoHdr 结构=====================================================================
        //VideoHdr 结构   定义了视频数据块的头信息，在编写回调函数时常用到其数据成员lpData（指向数据缓存的指针）和dwBufferLength（数据缓存的大小）。     
        //视频帧到缓存的捕获则需要应用回调函数和相应的数据块结构 VIDEOHDR 
        [StructLayout(LayoutKind.Sequential)]
        public struct VIDEOHDR
        {
            public IntPtr lpData;              /* 指向数据缓存的指针 */
            public int dwBufferLength;         /* 数据缓存的大小 */
            public int dwBytesUsed;            /* Bytes actually used */
            public int dwTimeCaptured;         /* Milliseconds from start of stream */
            public int dwUser;                 /* for client's use */
            public int dwFlags;                /* assorted flags (see defines) */
            public int dwReserved;             /* reserved for driver */
        }
        //=======================================================BitmapInfoHeader结构===================================================================
        //BitmapInfoHeader定义了位图的头部信息
        [StructLayout(LayoutKind.Sequential)]
        public struct BITMAPINFOHEADER
        {
            public int biSize;
            public int biWidth;
            public int biHeight;
            public short biPlanes;
            public short biBitCount;
            public int biCompression;
            public int biSizeImage;
            public int biXPelsPerMeter;
            public int biYPelsPerMeter;
            public int biClrUsed;
            public int biClrImportant;
        }
        //=========================================================================================================================================
        //======================================================BitmapInfo结构=====================================================================
        //BitmapInfo   位图信息
        [StructLayout(LayoutKind.Sequential)]
        public struct BITMAPINFO
        {
            public BITMAPINFOHEADER bmiHeader;
            public int bmiColors;
        }
        //=====================================================CAPTUREPARMS结构======================================================================
        //CAPTUREPARMS 包含控制视频流捕获过程的参数，如捕获帧频、指定键盘或鼠标键以终止捕获、捕获时间限制等； 
        [StructLayout(LayoutKind.Sequential)]
        public struct CAPTUREPARMS
        {
            public int dwRequestMicroSecPerFrame;             // 期望的桢播放率，以毫秒为单位，默认为66667，相当于15桢每秒。
            public bool fMakeUserHitOKToCapture;             // Show "Hit OK to cap" dlg?开始捕获标志位，如果值为真，则在开始捕获前要产生一个询问对话框，默认为假。
            public uint wPercentDropForError;               //所允许的最大丢桢百分比，可以从0变化到100，默认值为10。
            public bool fYield;                     /*另起线程标志位，如果为真，则程序重新启动一个线程用于视频流的捕获，默认值是假。
                                                     但是如果你是为了真，你必须要在程序中处理一些潜在的操作，因为当视频捕获时，其他操作并没有被屏蔽。*/
            public int dwIndexSize;                       // 在AVI文件中所允许的最大数目的索引项(32K)
            public uint wChunkGranularity;               // AVI文件的逻辑尺寸，以字节为单位。如果值是0，则说明该尺寸渐增 在 Win32程序中无用。(2K)
            public bool fUsingDOSMemory;                // Use DOS buffers?
            public uint wNumVideoRequested;            // 所被允许分配的最大视频缓存
            public bool fCaptureAudio;                // 音频标志位，如果音频流正在捕获，则该值为真。
            public uint wNumAudioRequested;          // 最大数量的音频缓存，默认值为10。
            public uint vKeyAbort;                  // 终止流捕获的虚拟键盘码，默认值为VK_ESCAPE
            [MarshalAs(UnmanagedType.Bool)]
            public bool fAbortLeftMouse;           // 终止鼠标左键标志位，如果该值为真，则在流捕获过程中如果点击鼠标左键则该捕获终止，默认值为真。
            public bool fAbortRightMouse;                 // Abort on right mouse?
            public bool fLimitEnabled;                   // 捕获操作时间限制，如果为真，则时间到了以后捕获操作终止，默认为假
            public uint wTimeLimit;                     // 具体终止时间，只有 fLimitEnabled是真时.该位才有效
            public bool fMCIControl;                   // Use MCI video source?
            public bool fStepMCIDevice;               // Step MCI device?MCI 设备标志。
            public int dwMCIStartTime;               // Time to start in MS
            public int dwMCIStopTime;               // Time to stop in MS
            public bool fStepCaptureAt2x;          // Perform spatial averaging 2x
            public int wStepCaptureAverageFrames; // 当基于平均采样来创建桢时，桢的采样时间，典型值是5
            public int dwAudioBufferSize;        // 音频缓存的尺寸，如果用默认值0，缓存尺寸是最大0.5秒，或10k字节。
            public int fDisableWriteCache;      // Attempt to disable write cache
            public int AVStreamMaster;         //音视频同步标志。
        }
        //=========================================================================================================================================
        //=================================================CAPDRIVERCAPS结构=======================================================================
        //CAPDRIVERCAPS定义了捕获驱动器的能力，如有无视频叠加能力、有无控制视频源、视频格式的对话框等； 
        [StructLayout(LayoutKind.Sequential)]
        public struct CAPDRIVERCAPS
        {
            [MarshalAs(UnmanagedType.U2)]
            public UInt16 wDeviceIndex;         //捕获驱动器的索引值，该值可以由0到9变化。
            [MarshalAs(UnmanagedType.Bool)]
            public bool fHasOverlay;            // 视频叠加标志，如果设备支持视频叠加这该位是真。
            [MarshalAs(UnmanagedType.Bool)]
            public bool fHasDlgVideoSource;     //视频资源对话框标志位，如果设备支持视频选择、控制对话框，该值为真。
            [MarshalAs(UnmanagedType.Bool)]
            public bool fHasDlgVideoFormat;     //视频格式对话框标志位，如果设备支持对视频格式对话框的选择，该位真。
            [MarshalAs(UnmanagedType.Bool)]
            public bool fHasDlgVideoDisplay;    //视频展示对话框标志位，如果设备支持对视频捕获缓存区的重新播放，该位是真。
            [MarshalAs(UnmanagedType.Bool)]
            public bool fCaptureInitialized;    //捕获安装标志位，如果捕获驱动器已经成功连接，该值为真。
            //[MarshalAs(UnmanagedType.Bool)]
            public bool fDriverSuppliesPalettes; //驱动器调色板标志位，如果驱动器能创建调色板，则该位是真。
            [MarshalAs(UnmanagedType.I4)]
            public int hVideoIn;
            [MarshalAs(UnmanagedType.I4)]
            public int hVideoOut;
            [MarshalAs(UnmanagedType.I4)]
            public int hVideoExtIn;
            [MarshalAs(UnmanagedType.I4)]
            public int hVideoExtOut;
        }
        //=========================================================================================================================================

        //=====================================================CAPSTATUS结构========================================================================
        //CAPSTATUS定义了捕获窗口的当前状态，如图像的宽、高等；
        [StructLayout(LayoutKind.Sequential)]
        public struct CAPSTATUS
        {
            public int uiImageWidth;                         //图像宽度
            public int uiImageHeight;                       //图像高度
            public bool fLiveWindow;                       //活动窗口标记，如果窗口正以预览的方式展示图像，那么该值为真
            public bool fOverlayWindow;                   //叠加窗口标志位，如果正在使用硬件叠加，则该位是真。
            public bool fScale;                          //输入所放标志位，如果窗口是正在缩放视频到客户区，那么该位是真。当使用硬件叠加时，改位无效。
            public Point ptScroll;                      //被展示在窗口客户区左上角的那个象素的x、y坐标偏移量。
            public bool fUsingDefaultPalette;          //默认调色板标志位，如果捕获窗口正在使用当前默认调色板，该值为真
            public bool fAudioHardware;               // 音频硬件标志位，如果系统已经安装了音频硬件，该值为真。
            public bool fCapFileExists;              //捕获文件标志位，如果一个捕获文件已经被创建，该值为真
            public int dwCurrentVideoFrame;         // 当前或最近流捕获过程中，所处理的桢的数目。包括丢弃的桢。
            public int dwCurrentVideoFramesDropped;//当前流捕获过程中丢弃的桢的数目。
            public int dwCurrentWaveSamples;      // # of wave samples cap'td
            public int dwCurrentTimeElapsedMS;   // 从当前流捕获开始计算，程序所用的时间，以毫秒为单位。
            public IntPtr hPalCurrent;          // 当前剪切板的句柄。
            public bool fCapturingNow;         // 捕获标志位，当捕获是正在进行时，改位是真
            public int dwReturn;              // 错误返回值，当你的应用程序不支持错误回调函数时可以应用改位
            public int wNumVideoAllocated;   // 被分配的视频缓存的数目。
            public int wNumAudioAllocated;  // 被分配的音频缓存的数目。
        }
        //=========================================================================================================================================

        #endregion 结构 VIDEOHDR|BITMAPINFOHEADER|BITMAPINFO|CAPTUREPARMS|CAPDRIVERCAPS|CAPSTATUS
    }
    public class cVideo     //视频类
    {
        public bool flag = true;
        private IntPtr lwndC;       //保存无符号句柄
        private IntPtr mControlPtr; //保存管理指示器
        private int mWidth;
        private int mHeight;
        public delegate void RecievedFrameEventHandler(byte[] data);
        public event RecievedFrameEventHandler RecievedFrame;
        public VideoAPI.CAPTUREPARMS Capparms;
        private VideoAPI.FrameEventHandler mFrameEventHandler;
        public VideoAPI.CAPDRIVERCAPS CapDriverCAPS;//捕获驱动器的能力，如有无视频叠加能力、有无控制视频源、视频格式的对话框等；
        public VideoAPI.CAPSTATUS CapStatus;//该结构用于保存视频设备捕获窗口的当前状态，如图像的宽、高等
        string strFileName;
        public cVideo(IntPtr handle, int width, int height)
        {
            CapDriverCAPS = new VideoAPI.CAPDRIVERCAPS();//捕获驱动器的能力，如有无视频叠加能力、有无控制视频源、视频格式的对话框等；
            CapStatus = new VideoAPI.CAPSTATUS();//该结构用于保存视频设备捕获窗口的当前状态，如图像的宽、高等
            mControlPtr = handle; //显示视频控件的句柄
            mWidth = width;      //视频宽度
            mHeight = height;    //视频高度
        }
        /// <summary>
        /// 打开视频设备
        /// </summary>
        public bool StartWebCam()
        {
            //byte[] lpszName = new byte[100];
            //byte[] lpszVer = new byte[100];
            //VideoAPI.capGetDriverDescriptionA(0, lpszName, 100, lpszVer, 100);
            //this.lwndC = VideoAPI.capCreateCaptureWindowA(lpszName, VideoAPI.WS_CHILD | VideoAPI.WS_VISIBLE, 0, 0, mWidth, mHeight, mControlPtr, 0);
            //if (VideoAPI.SendMessage(lwndC, VideoAPI.WM_CAP_DRIVER_CONNECT, 0, 0))
            //{
            //    VideoAPI.SendMessage(lwndC, VideoAPI.WM_CAP_SET_PREVIEWRATE, 100, 0);
            //    VideoAPI.SendMessage(lwndC, VideoAPI.WM_CAP_SET_PREVIEW, true, 0);
            //    return true;
            //}
            //else
            //{
            //    return false;
            //}
            this.lwndC = VideoAPI.capCreateCaptureWindow("", VideoAPI.WS_CHILD | VideoAPI.WS_VISIBLE, 0, 0, mWidth, mHeight, mControlPtr, 0);//AVICap类的捕捉窗口
            VideoAPI.FrameEventHandler FrameEventHandler = new VideoAPI.FrameEventHandler(FrameCallback);
            VideoAPI.SendMessage(this.lwndC, VideoAPI.WM_CAP_SET_CALLBACK_ERROR, 0, 0);//注册错误回调函数
            VideoAPI.SendMessage(this.lwndC, VideoAPI.WM_CAP_SET_CALLBACK_STATUS, 0, 0);//注册状态回调函数 
            VideoAPI.SendMessage(this.lwndC, VideoAPI.WM_CAP_SET_CALLBACK_VIDEOSTREAM, 0, 0);//注册视频流回调函数
            VideoAPI.SendMessage(this.lwndC, VideoAPI.WM_CAP_SET_CALLBACK_FRAME, 0, FrameEventHandler);//注册帧回调函数
            //if (!CapDriverCAPS.fCaptureInitialized)//判断当前设备是否被其他设备连接已经连接
            //{
            if (VideoAPI.SendMessage(this.lwndC, VideoAPI.WM_CAP_DRIVER_CONNECT, 0, 0))
            {
                //-----------------------------------------------------------------------
                VideoAPI.SendMessage(this.lwndC, VideoAPI.WM_CAP_DRIVER_GET_CAPS, VideoAPI.SizeOf(CapDriverCAPS), ref CapDriverCAPS);//获得当前视频 CAPDRIVERCAPS定义了捕获驱动器的能力，如有无视频叠加能力、有无控制视频源、视频格式的对话框等；
                VideoAPI.SendMessage(this.lwndC, VideoAPI.WM_CAP_GET_STATUS, VideoAPI.SizeOf(CapStatus), ref CapStatus);//获得当前视频流的尺寸 存入CapStatus结构
                VideoAPI.BITMAPINFO bitmapInfo = new VideoAPI.BITMAPINFO();//设置视频格式 (height and width in pixels, bits per frame). 
                bitmapInfo.bmiHeader = new VideoAPI.BITMAPINFOHEADER();
                bitmapInfo.bmiHeader.biSize = VideoAPI.SizeOf(bitmapInfo.bmiHeader);
                bitmapInfo.bmiHeader.biWidth = mWidth;
                bitmapInfo.bmiHeader.biHeight = mHeight;
                bitmapInfo.bmiHeader.biPlanes = 1;
                bitmapInfo.bmiHeader.biBitCount = 24;
                VideoAPI.SendMessage(this.lwndC, VideoAPI.WM_CAP_SET_PREVIEWRATE, 40, 0);//设置在PREVIEW模式下设定视频窗口的刷新率 设置每40毫秒显示一帧，即显示帧速为每秒25帧
                VideoAPI.SendMessage(this.lwndC, VideoAPI.WM_CAP_SET_SCALE, 1, 0);//打开预览视频的缩放比例
                VideoAPI.SendMessage(this.lwndC, VideoAPI.WM_CAP_SET_VIDEOFORMAT, VideoAPI.SizeOf(bitmapInfo), ref bitmapInfo);
                this.mFrameEventHandler = new VideoAPI.FrameEventHandler(FrameCallback);
                this.capSetCallbackOnFrame(this.lwndC, this.mFrameEventHandler);

                VideoAPI.CAPTUREPARMS captureparms = new VideoAPI.CAPTUREPARMS();
                VideoAPI.SendMessage(this.lwndC, VideoAPI.WM_CAP_GET_SEQUENCE_SETUP, VideoAPI.SizeOf(captureparms), ref captureparms);
                if (CapDriverCAPS.fHasOverlay)
                {
                    VideoAPI.SendMessage(this.lwndC, VideoAPI.WM_CAP_SET_OVERLAY, 1, 0);//启用叠加 注：据说启用此项可以加快渲染速度    
                }
                VideoAPI.SendMessage(this.lwndC, VideoAPI.WM_CAP_SET_PREVIEW, 1, 0);//设置显示图像启动预览模式 PREVIEW
                VideoAPI.SetWindowPos(this.lwndC, 0, 0, 0, mWidth, mHeight, VideoAPI.SWP_NOZORDER | VideoAPI.SWP_NOMOVE);//使捕获窗口与进来的视频流尺寸保持一致
                return true;
            }
            else
            {
                flag = false;
                return false;
            }
        }
        public void get()
        {
            VideoAPI.SendMessage(this.lwndC, VideoAPI.WM_CAP_GET_SEQUENCE_SETUP, VideoAPI.SizeOf(Capparms), ref Capparms);
        }
        public void set()
        {
            VideoAPI.SendMessage(this.lwndC, VideoAPI.WM_CAP_SET_SEQUENCE_SETUP, VideoAPI.SizeOf(Capparms), ref Capparms);
        }
        private bool capSetCallbackOnFrame(IntPtr lwnd, VideoAPI.FrameEventHandler lpProc)
        {
            return VideoAPI.SendMessage(this.lwndC, VideoAPI.WM_CAP_SET_CALLBACK_FRAME, 0, lpProc);
        }
        /// <summary>
        /// 关闭视频设备
        /// </summary>
        public void CloseWebcam()
        {
            VideoAPI.SendMessage(lwndC, VideoAPI.WM_CAP_DRIVER_DISCONNECT, 0, 0);
        }
        ///   <summary>   
        ///   拍照
        ///   </summary>   
        ///   <param  >要保存bmp文件的路径</param>   
        public void GrabImage(IntPtr hWndC, string path)
        {
            IntPtr hBmp = Marshal.StringToHGlobalAnsi(path);
            VideoAPI.SendMessage(lwndC, VideoAPI.WM_CAP_SAVEDIB, 0, hBmp.ToInt32());
        }
        public void StarKinescope(string path)
        {
            strFileName = path;
            string dir = path.Remove(path.LastIndexOf("//"));
            if (!File.Exists(dir))
            {
                Directory.CreateDirectory(dir);
            }
            int hBmp = Marshal.StringToHGlobalAnsi(path).ToInt32();
            bool b = VideoAPI.SendMessage(this.lwndC, VideoAPI.WM_CAP_FILE_SET_CAPTURE_FILE, 0, hBmp);
            b = VideoAPI.SendMessage(this.lwndC, VideoAPI.WM_CAP_SEQUENCE, 0, 0);
        }
        /// <summary>
        /// 停止录像
        /// </summary>
        public void StopKinescope()
        {
            VideoAPI.SendMessage(lwndC, VideoAPI.WM_CAP_STOP, 0, 0);
        }
        private void FrameCallback(IntPtr lwnd, IntPtr lpvhdr)
        {
            VideoAPI.VIDEOHDR videoHeader = new VideoAPI.VIDEOHDR();
            byte[] VideoData;
            videoHeader = (VideoAPI.VIDEOHDR)VideoAPI.GetStructure(lpvhdr, videoHeader);
            VideoData = new byte[videoHeader.dwBytesUsed];
            VideoAPI.Copy(videoHeader.lpData, VideoData);
            if (this.RecievedFrame != null)
                this.RecievedFrame(VideoData);
        }               
      }
}








悟無生
关注
  • 1
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C#结合AForge实现摄像头录像
12-31
输出为MP4需要用到ffmpeg相关的文件,我打包的库已经带了,去官网找的库可以在这个目录找到: 2: 添加这些引用: 3: 两个全局变量: //用来操作摄像头 private VideoCaptureDevice Camera = null; //用来把每一帧图像编码到视频文件 private VideoFileWriter VideoOutPut = new VideoFileWriter(); 开始代码: //获取摄像头列表 var devs = new FilterInfoCollection(FilterCategory.VideoInputDevice); //实例化
C# 获取摄像头录像
12-08
通过avicap32.dll函数实现获取摄像头、录像
C#使用OpenCvSharp3实现摄像头录制及拍照功能
最新发布
huang_peijia的专栏
02-24 600
这边有这样的需求，需要对特定的生产片段进行录像，由我系统进行控制。最开始测试了AForge的开源库，但发现x64的情况下，有些类库不能正常运行，才有了现在用的OpenCvSharp3的方式实现。摄像头：海康威视 DS-UVC-U64 Pro。首先，nuget OpenCvSharp3。
C#视频类
dz45693的专栏
09-29 3657
public class VideoAPI //视频API类 { // 视频ＡＰＩ调用 [DllImport("avicap32.dll")]//包含了执行视频捕获的函数，它给AVI文件I/O和视频、音频设备驱动程序提供一个高级接口 public static extern IntPtr capCreateCaptureWindow(st
onvif规范的实现：成功实现ONVIF协议RTSP-Video-Stream与OnvifDeviceManager的视频对接
热门推荐
ghostyu的专栏
11-22 14万+
有了前几篇的基础，现在可以正式开始onvif的实现工作，其中一项非常重要的部分就是视频流的对接，即能够在符合onvif标准的监控客户端软件里接收到设备端NVT发来的RTSP视频流。这里，我所用的客户端软件是Onvif Device Manager v2.2。【来自http://blog.csdn.net/ghostyu】 ONVIF Profile S Specification文档描述了Dev
C# 调用摄像头+保存视频
LYSM
06-21 8085
首先需要添加两个DLL为引用：DShowNET.dll、ICameraDll.dll 链接：https://pan.baidu.com/s/1nFfPbs-z9PsAeykJPcOmDQ 提取码：cok5 代码如下： using System.IO; using ICameraDll.DirectX.Capture; Capture capture; //摄像头录像操作 ...
用c#实现摄像头连接和拍照及麦克风、扬声器音量获取及设置
m0_65466579的博客
04-18 3682
再拖一个button控件，将button属性的text改为”扫描“；再拖三个button控件，属性的text分别设置为”连接“、”拍照“、”关闭“再分别拖两个button控件，text分别设置为获取麦克风音量，设置麦克风音量；再拖一个label控件，text设为待检测；再分别拖两个button控件，text分别设置为获取扬声器音量，设置扬声器音量；分别双击Form1的”扫描“、”连接“、”拍照“、”关闭“控件 ，写入以下代码。(最好不要直接复制代码，先双击控件再在出来的代码段添加代码，不然可能运行不了）
【STM32调试（一）】串口发送像素，上位机解析显示。
later的博客
03-20 1万+
图片上位机一、思路二、STM32采集数据发送2.1、OV7725模组2.2、串口发送三、上位机接收，解析，显示保存2.1、接收解析2.2、数据格式转换2.3、遇到问题四、小结&开源 一、思路 二、STM32采集数据发送 2.1、OV7725模组 2.2、串口发送 有两种发送方式：高低位单独发送；合并一起发送。 发送内容：黑白，二值，彩图 三、上位机接收，解析，显示保存 2.1、接收解析 2...
C# 调用摄像头拍照以及录制视频功能(亲测)
01-04
C# Winform实现。 播放功能：“开始播放”“暂停播放”、“停止播放”、“播放”功能；“播放”即播放自己录制的流媒体（可供用户选择路径）。
C#实现Onvif对接摄像机视频流，PTZ云台控制，预置位，VLC播放网络视频源
12-23
自己项目需要，编写此DEMO程序，亲测可用，调试前请更改libvlc的位置路径。 之前反馈代码被加密，所以重新上传，实现主要功能如下： 1、通过onvif协议获取摄像机RTSP视频流地址，并预览播放。 2、通过onvif协议对摄像机进行PTZ云台控制。 3、通过onvif协议设置和调用摄像机预置位功能。 4、通过VLC开源播放器预览播放摄像机RTSP视频流和网络视频源，VLC版本：3.0.4.0 5、提供Web Api接口getcamerastreamuri，传入参摄像机ip、port、username、password可以获取此摄像机的RTSP视频流地址。
C#使用Aforge调用摄像头拍照的方法
01-01
本文实例为大家分享了C#使用Aforge调用摄像头拍照的具体代码，供大家参考，具体内容如下 一、新建一个Winform项目 二、使用Nuget添加引用 安装下图中红色框住的两个程序包 安装完后发现安装了如下图的程序包，这是因为上述两个程序包存在对其它程序包的依赖。 三、编写程序 1.窗体设计，摄像头是下拉列表（cmbCamera，控件命名，下同），虽然示例只用到一个摄像头，但是该Demo可用于多个摄像头间切换场景，分辨率是下拉列表（cmbResolution），列出摄像头所支持的分辨率，一个VideoSourcePlayer控件（vispShoot），一个PictureBox控件（pic
C#实现从视频文件中读取关键帧数据源代码
05-13
C#实现从视频文件中读取关键帧数据源代码
C# LED数码管控件可以用
06-13
从网站上面下载的开源控件，建议大家需要的话，可以GooGle搜索，会有惊喜的。
C#调用AForge实现摄像头录像的示例代码
12-31
1:首先下载库文件>> 也可以去官网寻找>> 下载本教程全代码>> 输出为MP4需要用到ffmpeg相关的文件,我打包的库已经带了,去官网找的库可以在这个目录找到:... //获取摄像头列表 var devs = new FilterInfoCollection(Filt
C#Winform摄像头的视频录制和播放
09-20
C# Winform实现图像的动态采集，采集到的流媒体按照*.wam或者任意一种Windows Media Player 11可以播放的文件格式， 并获取流媒体采集结束时的最后画面作为流媒体的封面。 要求有录像功能：“开始录像”、“暂停...
C#捕获摄像头进行拍照和录像资料总结
weixin_33796205的博客
10-12 291
1..net中捕获摄像头视频的方式及对比** 2.用Directshow.net的播放控件http://www.360doc.com/content/09/0307/16/50415_2739439.shtml 3。DirectShow.Net下载http://sourceforge.net/projects/directshownet/ 4。DirectShow .Net 实现视频预...
用c#调用摄像头做录像功能
xyq0125的专栏
07-01 2304
Code: using System.Runtime.InteropServices;    using System.Drawing;    using System.Drawing.Imaging;    using System;       namespace CamTest2    {   
c# 获取onvif协议摄像头数据流
09-27
c是英文字母表中的第三个字母。它在许多不同的语言和方言中都有使用，比如汉语拼音系统中的"c"就表示着声母/ʨ/的发音。此外，在很多其他语言中，如英语、法语、西班牙语等，c也有其他不同的发音方式。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值