public Dictionary<int, CameraInfo> GetAllCameraInfo(ref string errMessage)
        {
            Database db = DatabaseFactory.CreateDatabase();
            errMessage = "";
            Dictionary<int, CameraInfo> list = new Dictionary<int, CameraInfo>();
            try
            {

                DataSet ds = CameraDataAccess.GetAllCamInfo(db);

                CameraInfo oCamera;
                for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
                {
                    oCamera = new CameraInfo(ds.Tables[0].Rows[i]);
                    list.Add(oCamera.CameraId, oCamera);

                }
                return list;

            }
            catch (Exception ex)
            {
                errMessage = ex.Message + ex.StackTrace;
                logger.Error("Error Message:" + ex.Message + " Trace:" + ex.StackTrace);
                return null;
            }
        }
        public Dictionary<int, VideoInfo> GetVideoInfoByCamera(ref string errMessage, int cameraId)
        {
            Database db = DatabaseFactory.CreateDatabase();
            errMessage = "";
            var videoList = new Dictionary<int, VideoInfo>();
            try
            {

                DataSet ds = VideoDataAccess.GetVideoInfoByCamera(db, cameraId);

                VideoInfo videoInfo;
                for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
                {
                    videoInfo = new VideoInfo(ds.Tables[0].Rows[i]);
                    DataSet dsCamera;
                    CameraInfo oCamera;
                    dsCamera = CameraDataAccess.GetCamInfoByCameraId(db, videoInfo.CameraId);
                    foreach (DataRow dr in dsCamera.Tables[0].Rows)
                    {

                        oCamera = new CameraInfo(dr);
                        videoInfo.CameraInfo = oCamera;
                    }

                    videoList.Add(videoInfo.Id, videoInfo);
                }
                return videoList;

            }
            catch (Exception ex)
            {
                errMessage = ex.Message + ex.StackTrace;
                logger.Error("Error Message:" + ex.Message + " Trace:" + ex.StackTrace);
                return null;
            }
        }
        public void Start(CameraInfo camera, CardOutType cardOutType, int id)
        {
            CurrentCardOutType = cardOutType;
            CurrentCardOutId = id;
            IsValidChannel = false;
            NET_DVR_CLIENTINFO struClientInfo;  //定义预览参数结构体
            struClientInfo.lChannel = camera.ChannelNo;
            struClientInfo.lLinkMode = 0;
            struClientInfo.hPlayWnd = IntPtr.Zero; //camera.Handle;
            int m_iSubWndIndex = 1000;  //用户数据
            struClientInfo.sMultiCastIP = "0.0.0.0";
            // 实时预览 不回调
            // m_lPlayHandle = HCNetSDK.NET_DVR_RealPlay_V30(_deviceInfo.ServiceID, ref struClientInfo, null, m_iSubWndIndex, true);
            //实时预览 回调
            _cameraInfo = camera;
            ListPorts = new Dictionary<int, IntPtr>();
            switch (cardOutType)
            {
                case CardOutType.DefaultDisplay:
                    stream_callback = new RealDataCallBack_V30(g_DefaultRealDataCallBack_V30);
                    break;
                case CardOutType.SynGroup:
                    stream_callback = new RealDataCallBack_V30(g_SynGroupRealDataCallBack_V30);
                    break;
                case CardOutType.GroupSwitch:
                    stream_callback = new RealDataCallBack_V30(g_GroupSwitchRealDataCallBack_V30);
                    break;
                case CardOutType.ProgSwitch:
                    stream_callback = new RealDataCallBack_V30(g_ProgSwitchRealDataCallBack_V30);
                    break;

                default:
                    stream_callback = new RealDataCallBack_V30(g_RealDataCallBack_V30);
                    break;
            }

            GCHandle aa = GCHandle.Alloc(stream_callback);
            GCHandle bb = GCHandle.Alloc(serial_callback);
            m_lPlayHandle = HCNetSDK.NET_DVR_RealPlay_V30(_deviceInfo.ServiceID, ref struClientInfo, stream_callback, m_iSubWndIndex, true);

            //m_lPlayHandle = HCNetSDK.NET_DVR_RealPlay_V30(_deviceInfo.ServiceID, ref struClientInfo, null, m_iSubWndIndex, true);
            camera.PlayHandle = m_lPlayHandle;

            int SerialHandle = -1;
            if (!ListSerialHandle.ContainsKey(_deviceInfo.DeviceId))
            {
                serial_callback = new HCNetSDK.SerialDataCallBack(g_SerialDataCallBack);
                SerialHandle = HCNetSDK.NET_DVR_SerialStart(_deviceInfo.ServiceID, 1, serial_callback, (uint)m_iSubWndIndex);
                if (SerialHandle != -1)
                {
                    ListSerialHandle.Add(_deviceInfo.DeviceId, SerialHandle);
                }
            }

            camera.SerialHandle = SerialHandle;
            _cameraInfo = camera;
            if (m_lPlayHandle > -1)
            {
                IsValidChannel = true;
            }
            processFile = AppDomain.CurrentDomain.BaseDirectory + "Temp\\";
            if (!Directory.Exists(processFile))
            {
                Directory.CreateDirectory(processFile);
            }
            TempPath = processFile;
            processFile = processFile + "delectfile.jpg";
            _cameraInfo = camera;
            if (thread == null)
            {

                stopEvent = new ManualResetEvent(false);
                thread = new Thread(WorkerThread);
                thread.Name = camera.Name;
                thread.Start();
            }
        }
        private void GenerateInputCam()
        {
            int iVideoCount = 0;
            int iViddeoStartNo=0;

            List<CameraInfo> list = new List<CameraInfo>();
            if (!int.TryParse(txtVideoCount.Text, out iVideoCount))
            {
                XtraMessageBox.Show("��Ƶ����������Ϊ��?", "��ע��");
                return ;
            }
            if (iVideoCount <= 0)
            {
                XtraMessageBox.Show("��Ƶ���������������?", "��ע��");
                return ;
            }
            if (!int.TryParse(txtViddeoStartNo.Text, out iViddeoStartNo))
            {
                XtraMessageBox.Show("��Ƶ���뿪ʼ�Ų���Ϊ��?", "��ע��");
                return;
            }
            if (iViddeoStartNo < 0)
            {
                XtraMessageBox.Show("��Ƶ���뿪ʼ�ű�����ڻ������?", "��ע��");
                return;
            }
            //txtViddeoStartNo
            CameraInfo oCameraInfo = new CameraInfo();
            for (int i = 0; i < iVideoCount; i++)
            {
                oCameraInfo = new CameraInfo();
                oCameraInfo.Name = string.Format("�����{0}", i+1);
                oCameraInfo.AddressID = i+1;
                oCameraInfo.ChannelNo = iViddeoStartNo;
                oCameraInfo.ConnURL = "Com1";
                oCameraInfo.Oupputpath = "d:\\videoutput";
                oCameraInfo.IsValid = true;
                oCameraInfo.IsDetect = false;
                list.Add(oCameraInfo);
                iViddeoStartNo = iViddeoStartNo + 1;

            }
            gdCamera.DataSource = list;
        }
        public Dictionary<int, RecognizerInfo> GetAllRecognizerInfo(ref string errMessage)
        {
            Database db = DatabaseFactory.CreateDatabase();
            errMessage = "";
            Dictionary<int, RecognizerInfo> mylist = new Dictionary<int, RecognizerInfo>();
            try
            {
                RecognizerInfo oRecognizerInfo;
                DataSet ds = RecognizerDataAccess.GetAllRecInfo(db);
                DataSet dsCamera;
                CameraInfo oCamera;

                for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
                {
                    oRecognizerInfo = new RecognizerInfo(ds.Tables[0].Rows[i]);
                    dsCamera = RecognizerDataAccess.GetCameraInfoByRecognizerId(db, oRecognizerInfo.Id);
                    oRecognizerInfo.ListCameras = new Dictionary<int, CameraInfo>();
                    foreach (DataRow dr in dsCamera.Tables[0].Rows)
                    {

                        oCamera = new CameraInfo(dr);
                        oRecognizerInfo.ListCameras.Add(oCamera.CameraId, oCamera);
                    }
                    mylist.Add(oRecognizerInfo.Id, oRecognizerInfo);
                }
                return mylist;

            }
            catch (Exception ex)
            {
                errMessage = ex.Message + ex.StackTrace;
                logger.Error("Error Message:" + ex.Message + " Trace:" + ex.StackTrace);
                return null;
            }
        }
        public Dictionary<int, DeviceInfo> GetDeviceInfoByGroupId(ref string errMessage, int GroupId)
        {
            Database db = DatabaseFactory.CreateDatabase();
            errMessage = "";
            try
            {
                Dictionary<int, DeviceInfo> list = new Dictionary<int, DeviceInfo>();
                DataSet ds = DeviceDataAccess.GetDeviceInfoByGroupId(db, GroupId);
                if (ds.Tables[0].Rows.Count == 0)
                {
                    return null;
                }
                DataSet dsCamera;
                CameraInfo oCamera;
                DeviceInfo oDeviceInfo;
                DataSet dsAlarm;
                AlarmInfo oAlarm;
                for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
                {
                    oDeviceInfo = new DeviceInfo(ds.Tables[0].Rows[i]);

                    oDeviceInfo.ListCamera = new Dictionary<int, CameraInfo>();

                    dsCamera = CameraDataAccess.GetCamInfoByDeviceId(db, oDeviceInfo.DeviceId);
                    foreach (DataRow drCam in dsCamera.Tables[0].Rows)
                    {
                        oCamera = new CameraInfo(drCam);
                        oDeviceInfo.ListCamera.Add(oCamera.CameraId, oCamera);
                    }

                    oDeviceInfo.ListAlarm = new Dictionary<int, AlarmInfo>();

                    dsAlarm = AlarmDataAccess.GetAlarmInfoByDeviceId(db, oDeviceInfo.DeviceId);
                    foreach (DataRow drAlarm in dsAlarm.Tables[0].Rows)
                    {
                        oAlarm = new AlarmInfo(drAlarm);
                        oDeviceInfo.ListAlarm.Add(oAlarm.AlarmId, oAlarm);
                    }

                    list.Add(oDeviceInfo.DeviceId, oDeviceInfo);

                }
                return list;

            }
            catch (Exception ex)
            {
                errMessage = ex.Message + ex.StackTrace;
                logger.Error("Error Message:" + ex.Message + " Trace:" + ex.StackTrace);
                return null;
            }
        }
        public GroupInfo GetGroupInfoByGroupName(ref string errMessage, string groupName)
        {
            Database db = DatabaseFactory.CreateDatabase();
            errMessage = "";
            try
            {
                DataSet ds = GroupDataAccess.GetGroupInfoByGroupName(db, groupName);
                if (ds.Tables[0].Rows.Count == 0)
                {
                    return null;
                }
                DataSet dsDevice;
                DataSet dsCamera;
                CameraInfo oCamera;
                DeviceInfo oDevice;
                DataSet dsAlarm;
                AlarmInfo oAlarm;

                GroupInfo oGroupInfo = new GroupInfo(ds.Tables[0].Rows[0]);
                dsDevice = DeviceDataAccess.GetDeviceInfoByGroupId(db, oGroupInfo.GroupID);
                oGroupInfo.ListDevice = new Dictionary<int, DeviceInfo>();
                foreach (DataRow dr in ds.Tables[0].Rows)
                {
                    oDevice = new DeviceInfo(dr);
                    oDevice.ListCamera = new Dictionary<int, CameraInfo>();
                    dsCamera = CameraDataAccess.GetCamInfoByDeviceId(db, oDevice.DeviceId);
                    foreach (DataRow drCam in dsCamera.Tables[0].Rows)
                    {
                        oCamera = new CameraInfo(drCam);
                        oDevice.ListCamera.Add(oCamera.CameraId, oCamera);
                    }
                    oDevice.ListAlarm = new Dictionary<int, AlarmInfo>();
                    dsAlarm = AlarmDataAccess.GetAlarmInfoByDeviceId(db, oDevice.DeviceId);
                    foreach (DataRow drAlarm in dsAlarm.Tables[0].Rows)
                    {
                        oAlarm = new AlarmInfo(drAlarm);
                        oDevice.ListAlarm.Add(oAlarm.AlarmId, oAlarm);
                    }
                    oGroupInfo.ListDevice.Add(oDevice.DeviceId, oDevice);

                }

                return oGroupInfo;

            }
            catch (Exception ex)
            {
                errMessage = ex.Message + ex.StackTrace;
                logger.Error("Error Message:" + ex.Message + " Trace:" + ex.StackTrace);
                return null;
            }
        }
 // Start video source
 public void Start(ref CameraInfo cameraInfo)
 {
     _cameraInfo = cameraInfo;
     if (_videoSource != null)
     {
         _videoSource.NewFrame += new CameraEventHandler(video_NewFrame);
         _videoSource.Handle = _cameraInfo.Handle;
         _videoSource.Start(ref cameraInfo);
         _cameraInfo = cameraInfo;
     }
 }
        public static int Update(Database db, CameraInfo oCameraInfo)
        {
            StringBuilder sb = new StringBuilder();
            sb.Append("update CameraInfo set");
            sb.AppendFormat(" Name='{0}'", oCameraInfo.Name);
            sb.AppendFormat(",Description='{0}'", oCameraInfo.Description);
            sb.AppendFormat(",IsValid={0}", oCameraInfo.IsValid);
            sb.AppendFormat(",ChannelNo={0}", oCameraInfo.ChannelNo);
            sb.AppendFormat(",AddressID={0}", oCameraInfo.AddressID);
            sb.AppendFormat(",ConnURL='{0}'", oCameraInfo.ConnURL);
            sb.AppendFormat(",Remark='{0}'", oCameraInfo.Remark);
            sb.AppendFormat(",Oupputpath='{0}'", oCameraInfo.Oupputpath);
            sb.AppendFormat(",ModifyBy='{0}'", oCameraInfo.AddBy);
            sb.AppendFormat(",ModifyTime='{0}')", oCameraInfo.AddTime);
            sb.AppendFormat(",frameInterval={0})", oCameraInfo.frameInterval);

            sb.AppendFormat(",resolution='{0}'", oCameraInfo.resolution);
            sb.AppendFormat(",quality='{0}')", oCameraInfo.quality);
            sb.AppendFormat(",StreamType={0})", oCameraInfo.StreamType);

            sb.AppendFormat(" where CameraId={0})", oCameraInfo.CameraId);
            string cmdText = sb.ToString();
            try
            {
                return db.ExecuteNonQuery(CommandType.Text, cmdText);

            }
            catch (Exception ex)
            {

                throw ex;
            }
        }
        public VideoInfo GetVideoInfoById(ref string errMessage, int id)
        {
            Database db = DatabaseFactory.CreateDatabase();
            errMessage = "";
            try
            {
                DataSet ds = VideoDataAccess.GetVideoInfoById(db, id);
                if (ds.Tables[0].Rows.Count == 0)
                {
                    return null;
                }
                VideoInfo videoInfo = new VideoInfo(ds.Tables[0].Rows[0]);
                DataSet dsCamera;
                CameraInfo oCamera;
                dsCamera = CameraDataAccess.GetCamInfoByCameraId(db, videoInfo.CameraId);
                foreach (DataRow dr in dsCamera.Tables[0].Rows)
                {

                    oCamera = new CameraInfo(dr);
                    videoInfo.CameraInfo =  oCamera;
                }
                return videoInfo;
            }
            catch (Exception ex)
            {
                errMessage = ex.Message + ex.StackTrace;
                logger.Error("Error Message:" + ex.Message + " Trace:" + ex.StackTrace);
                return null;
            }
        }
        // Start work
        public void Start(ref CameraInfo cameraInfo)
        {
            if ((!_deviceInfo.IsReady) || _deviceInfo.ServiceID < 0)
            {
                return;
            }

            NET_DVR_CLIENTINFO struClientInfo;  //����Ԥ�������ṹ��
            struClientInfo.lChannel = cameraInfo.ChannelNo;
            struClientInfo.lLinkMode = 0;
            struClientInfo.hPlayWnd = cameraInfo.Handle;
            int m_iSubWndIndex = 0;  //�û�����
            struClientInfo.sMultiCastIP = "0.0.0.0";
            // ʵʱԤ�� ���ص�
               // m_lPlayHandle = HCNetSDK.NET_DVR_RealPlay_V30(_deviceInfo.ServiceID, ref struClientInfo, null, m_iSubWndIndex, true);
            //ʵʱԤ�� �ص�
            _cameraInfo = cameraInfo;
            //m_lPlayHandle = HCNetSDK.NET_DVR_RealPlay_V30(_deviceInfo.ServiceID, ref struClientInfo, new RealDataCallBack_V30(g_RealDataCallBack_V30), m_iSubWndIndex, true);
             m_lPlayHandle = HCNetSDK.NET_DVR_RealPlay_V30(_deviceInfo.ServiceID, ref struClientInfo,null, m_iSubWndIndex, true);

            cameraInfo.PlayHandle = m_lPlayHandle;
            if (m_lPlayHandle > -1)
            {
                isValidVideo = true;
            }
            _cameraInfo = cameraInfo;
              	if (thread == null)
            {
                framesReceived = 0;
                bytesReceived = 0;
                stopEvent	= new ManualResetEvent(false);
             		thread = new Thread(new ThreadStart(WorkerThread));
                thread.Name = source;
                thread.Start();
            }
        }
 public object GetConfiguration()
 {
     DeviceInfo config = new DeviceInfo();
     config.Name = _DeviceName;
     config.source = serverBox.Text;
     config.login = loginBox.Text;
     config.pwd = passwordBox.Text;
     config.IsCamera = 1;
     _listCam = new List<CameraInfo>();
     CameraInfo ocamera = new CameraInfo();
     ocamera.Name = _DeviceName;
     ocamera.resolution = sizeCombo.Text;
     ocamera.StreamType = 0;
     ocamera.quality = qualityCombo.Text;
     ocamera.frameInterval = frameIntervals[rateCombo.SelectedIndex];
     ocamera.Oupputpath = txtOutputpath.Text;
     ocamera.IsDetect = ckIsDetect.Checked;
     ocamera.IsValid = ckIsValid.Checked;
     ocamera.ConnURL = txtConnUrl.Text;
     ocamera.AddressID = int.Parse(txtAddressId.Text);
     _listCam.Add(ocamera);
     return (object)config;
 }
        public int Update(ref string errMessage, CameraInfo oCameraInfo)
        {
            Database db = DatabaseFactory.CreateDatabase();
            errMessage = "";
            try
            {
                return CameraDataAccess.Update(db, oCameraInfo);

            }
            catch (Exception ex)
            {
                errMessage = ex.Message + ex.StackTrace;
                logger.Error("Error Message:" + ex.Message + " Trace:" + ex.StackTrace);
                return -1;
            }
        }
        public DecoderInfo GetDecoderInfoByDecoderIP(ref string errMessage, string IP)
        {
            Database db = DatabaseFactory.CreateDatabase();
            errMessage = "";
            try
            {
                DataSet ds = DecoderDataAccess.GetDecoderInfoByDecoderIP(db, IP);
                if (ds.Tables[0].Rows.Count == 0)
                {
                    return null;
                }
                DecoderInfo decoderInfo = new DecoderInfo(ds.Tables[0].Rows[0]);
                DataSet dsCamera;
                CameraInfo oCamera;
                dsCamera = DecoderDataAccess.GetCameraInfoByDecoderId(db, decoderInfo.id);
                //DecoderDataAccess.GetCamInfoByCameraId(db,dsCamera.Tables[0].Rows[i].)
                decoderInfo.ListCameras = new Dictionary<int, CameraInfo>();
                foreach (DataRow dr in dsCamera.Tables[0].Rows)
                {

                    oCamera = new CameraInfo(dr);
                    decoderInfo.ListCameras.Add(oCamera.CameraId, oCamera);
                }
                return decoderInfo;

            }
            catch (Exception ex)
            {
                errMessage = ex.Message + ex.StackTrace;
                logger.Error("Error Message:" + ex.Message + " Trace:" + ex.StackTrace);
                return null;
            }
        }
Beispiel #15
0
        // Start work
        public void Start(ref CameraInfo cameraInfo)
        {
            _cameraInfo = cameraInfo;
            if (thread == null)
            {
                framesReceived = 0;
                bytesReceived = 0;

                // create events
                stopEvent	= new ManualResetEvent(false);

                // create and start new thread
                thread = new Thread(new ThreadStart(WorkerThread));
                thread.Name = source;
                thread.Start();
            }
        }
        public Dictionary<int, DecoderInfo> GetDecoderInfoByName(ref string errMessage, string Name)
        {
            Database db = DatabaseFactory.CreateDatabase();
            errMessage = "";
            Dictionary<int, DecoderInfo> mylist = new Dictionary<int, DecoderInfo>();
            try
            {

                DataSet ds = DecoderDataAccess.GetDecoderInfoByName(db, Name);

                DecoderInfo decoderInfo;
                for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
                {
                    decoderInfo = new DecoderInfo(ds.Tables[0].Rows[i]);
                    DataSet dsCamera;
                    CameraInfo oCamera;
                    dsCamera = DecoderDataAccess.GetCameraInfoByDecoderId(db, decoderInfo.id);
                    //DecoderDataAccess.GetCamInfoByCameraId(db,dsCamera.Tables[0].Rows[i].)
                    decoderInfo.ListCameras = new Dictionary<int, CameraInfo>();
                    foreach (DataRow dr in dsCamera.Tables[0].Rows)
                    {

                        oCamera = new CameraInfo(dr);
                        decoderInfo.ListCameras.Add(oCamera.CameraId, oCamera);
                    }

                    mylist.Add(decoderInfo.id, decoderInfo);
                }
                return mylist;

            }
            catch (Exception ex)
            {
                errMessage = ex.Message + ex.StackTrace;
                logger.Error("Error Message:" + ex.Message + " Trace:" + ex.StackTrace);
                return null;
            }
        }
        public static int Insert(Database db, CameraInfo oCameraInfo)
        {
            StringBuilder sbField = new StringBuilder();
            StringBuilder sbValue = new StringBuilder();
            int i;
            if (oCameraInfo.IsValid) i = 1;
            else i = 0;
            sbField.Append("INSERT INTO [CameraInfo](");
            sbValue.Append("values(");
            sbField.Append("[DeviceId]");
            sbValue.AppendFormat("{0}", oCameraInfo.DeviceId);
            sbField.Append(",[Name]");
            sbValue.AppendFormat(",'{0}'", oCameraInfo.Name);
            sbField.Append(",[Description]");
            sbValue.AppendFormat(",'{0}'", oCameraInfo.Description);
            sbField.Append(",[IsValid]");
            sbValue.AppendFormat(",{0}", i);
            sbField.Append(",[ChannelNo]");
            sbValue.AppendFormat(",{0}", oCameraInfo.ChannelNo);
            sbField.Append(",[AddressID]");
            sbValue.AppendFormat(",{0}", oCameraInfo.AddressID);
            sbField.Append(",[ConnURL]");
            sbValue.AppendFormat(",'{0}'", oCameraInfo.ConnURL);
            sbField.Append(",[Remark]");
            sbValue.AppendFormat(",'{0}'", oCameraInfo.Remark);
            sbField.Append(",[Oupputpath]");
            sbValue.AppendFormat(",'{0}'", oCameraInfo.Oupputpath);
            sbField.Append(",[frameInterval]");
            sbValue.AppendFormat(",{0}", oCameraInfo.frameInterval);

            sbField.Append(",[resolution]");
            sbValue.AppendFormat(",'{0}'", oCameraInfo.resolution);

            sbField.Append(",[quality]");
            sbValue.AppendFormat(",'{0}'", oCameraInfo.quality);

            sbField.Append(",[StreamType]");
            sbValue.AppendFormat(",{0}", oCameraInfo.StreamType);

            sbField.Append(",[AddBy]");
            sbValue.AppendFormat(",'{0}'", oCameraInfo.AddBy);
            sbField.Append(",[AddTime])");
            sbValue.AppendFormat(",'{0}')", oCameraInfo.AddTime);
            string cmdText = sbField.ToString() + " " + sbValue.ToString()  ;
            try
            {
                return  db.ExecuteNonQuery(CommandType.Text, cmdText);

            }
            catch (Exception ex)
            {

                throw ex;
            }
        }