Example #1
0
        public void RefreshIPDevLocalCfg(int iDeviceIndex)
        {
            CHCNetSDK.NET_DVR_IPPARACFG_V40 struIPAccessCfgV40 = g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruIPParaCfgV40[g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO];
            uint dwChanShow   = 0;
            int  iIPChanIndex = 0;
            int  i            = 0;

            g_deviceTree.g_struDeviceInfo[iDeviceIndex].iIPChanNum = (int)struIPAccessCfgV40.dwDChanNum;

            int iAnalogChanCount = 0;
            int iIPChanCount     = 0;
            int iGroupNO         = g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO; //Group NO.
            int iGroupNum        = (int)struIPAccessCfgV40.dwGroupNum;
            int iIPChanNum       = g_deviceTree.g_struDeviceInfo[iDeviceIndex].iIPChanNum;

            for (i = 0; i < CHCNetSDK.MAX_CHANNUM_V30; i++)
            {
                //analog channel
                if (iAnalogChanCount < g_deviceTree.g_struDeviceInfo[iDeviceIndex].iAnalogChanNum)
                {
                    dwChanShow = (uint)(iAnalogChanCount + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iStartChan + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64);

                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iDeviceIndex = iDeviceIndex;
                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iChanIndex   = i;
                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iChanType    = AcsDemoPublic.DEMO_CHANNEL_TYPE.DEMO_CHANNEL_TYPE_ANALOG;
                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iChannelNO   = (int)dwChanShow;

                    g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].pStruChanInfo[i].chChanName =
                        string.Format("Camera{0}", i + g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].iStartChan - g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].iAnalogChanNum);
                    //analog devices
                    if (struIPAccessCfgV40.byAnalogChanEnable[i] > 0)
                    {
                        g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].bEnable     = true;
                        g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].dwImageType = AcsDemoPublic.CHAN_ORIGINAL;
                        //g_struDeviceInfo[iDeviceIndex].iEnableChanNum ++;
                    }
                    else
                    {
                        g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].bEnable     = false;
                        g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].dwImageType = AcsDemoPublic.CHAN_OFF_LINE;
                    }

                    iAnalogChanCount++;
                }
                else if (iGroupNO >= 0 && ((iIPChanCount + iGroupNO * CHCNetSDK.MAX_CHANNUM_V30) < iIPChanNum) && (iIPChanCount < iIPChanNum))
                {
                    dwChanShow = (uint)(iIPChanCount + iGroupNO * CHCNetSDK.MAX_CHANNUM_V30 + struIPAccessCfgV40.dwStartDChan);

                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iChanType  = AcsDemoPublic.DEMO_CHANNEL_TYPE.DEMO_CHANNEL_TYPE_IP;
                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iChannelNO = (int)dwChanShow;

                    iIPChanIndex = iIPChanCount;
                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iDeviceIndex = iDeviceIndex;
                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iChanIndex   = i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64;
                    g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].pStruChanInfo[i].chChanName =
                        string.Format("IPCamera{0}", iIPChanCount + iGroupNO * CHCNetSDK.MAX_CHANNUM_V30 + 1);

                    if (struIPAccessCfgV40.struStreamMode[iIPChanIndex].uGetStream.struChanInfo.byIPID != 0 && struIPAccessCfgV40.struStreamMode[iIPChanIndex].uGetStream.struChanInfo.byEnable != 0)
                    {
                        g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].bEnable = true;//
                        if (struIPAccessCfgV40.struStreamMode[iIPChanIndex].uGetStream.struChanInfo.byEnable > 0)
                        {
                            g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].dwImageType = AcsDemoPublic.CHAN_ORIGINAL;
                        }
                        else
                        {
                            g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].dwImageType = AcsDemoPublic.CHAN_OFF_LINE;
                        }

                        //				g_struDeviceInfo[iDeviceIndex].iEnableChanNum ++;
                    }
                    else
                    {
                        g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].dwImageType = AcsDemoPublic.CHAN_OFF_LINE;
                        g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].bEnable     = false;
                        //g_struDeviceInfo[iDeviceIndex].struChanInfo[i].bAlarm = FALSE;
                    }

                    iIPChanCount++;
                }
                else
                {
                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iDeviceIndex    = -1;
                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iChanIndex      = -1;
                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iChanType       = AcsDemoPublic.DEMO_CHANNEL_TYPE.DEMO_CHANNEL_TYPE_INVALID;
                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iChannelNO      = -1;
                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].bEnable         = false;
                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].bAlarm          = false;
                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].bLocalManualRec = false;
                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].lRealHandle     = -1;
                    g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].pStruChanInfo[i].chChanName = "";
                }
            }

            for (i = 0; i < CHCNetSDK.MAX_CHANNUM_V40; i++)
            {
                if (g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].bEnable)
                {
                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].lFirstEnableChanIndex = i;
                    break;
                }
            }
        }
Example #2
0
        public void InfoIPChannel()
        {
            uint dwSize = (uint)Marshal.SizeOf(m_struIpParaCfgV40);

            IntPtr ptrIpParaCfgV40 = Marshal.AllocHGlobal((Int32)dwSize);

            Marshal.StructureToPtr(m_struIpParaCfgV40, ptrIpParaCfgV40, false);

            uint dwReturn = 0;
            int  iGroupNo = 0; //该Demo仅获取第一组64个通道,如果设备IP通道大于64路,需要按组号0~i多次调用NET_DVR_GET_IPPARACFG_V40获取

            if (!CHCNetSDK.NET_DVR_GetDVRConfig(m_lUserID, CHCNetSDK.NET_DVR_GET_IPPARACFG_V40, iGroupNo, ptrIpParaCfgV40, dwSize, ref dwReturn))
            {
                iLastErr = CHCNetSDK.NET_DVR_GetLastError();
                str1     = "NET_DVR_GET_IPPARACFG_V40 failed, error code= " + iLastErr; //获取IP资源配置信息失败,输出错误号
                MessageBox.Show(str1);
            }
            else
            {
                // succ
                m_struIpParaCfgV40 = (CHCNetSDK.NET_DVR_IPPARACFG_V40)Marshal.PtrToStructure(ptrIpParaCfgV40, typeof(CHCNetSDK.NET_DVR_IPPARACFG_V40));

                for (i = 0; i < dwAChanTotalNum; i++)
                {
                    ListAnalogChannel(i + 1, m_struIpParaCfgV40.byAnalogChanEnable[i]);
                    iChannelNum[i] = i + (int)DeviceInfo.byStartChan;
                }

                byte byStreamType;
                uint iDChanNum = 64;

                if (dwDChanTotalNum < 64)
                {
                    iDChanNum = dwDChanTotalNum; //如果设备IP通道小于64路,按实际路数获取
                }

                for (i = 0; i < iDChanNum; i++)
                {
                    iChannelNum[i + dwAChanTotalNum] = i + (int)m_struIpParaCfgV40.dwStartDChan;

                    byStreamType     = m_struIpParaCfgV40.struStreamMode[i].byGetStreamType;
                    m_unionGetStream = m_struIpParaCfgV40.struStreamMode[i].uGetStream;

                    switch (byStreamType)
                    {
                    //目前NVR仅支持0- 直接从设备取流一种方式
                    case 0:
                        dwSize = (uint)Marshal.SizeOf(m_unionGetStream);
                        IntPtr ptrChanInfo = Marshal.AllocHGlobal((Int32)dwSize);
                        Marshal.StructureToPtr(m_unionGetStream, ptrChanInfo, false);
                        m_struChanInfo = (CHCNetSDK.NET_DVR_IPCHANINFO)Marshal.PtrToStructure(ptrChanInfo, typeof(CHCNetSDK.NET_DVR_IPCHANINFO));

                        //列出IP通道
                        ListIPChannel(i + 1, m_struChanInfo.byEnable, m_struChanInfo.byIPID);
                        Marshal.FreeHGlobal(ptrChanInfo);
                        break;

                    default:
                        break;
                    }
                }
            }
            Marshal.FreeHGlobal(ptrIpParaCfgV40);
        }
Example #3
0
        public bool DoGetDeviceResoureCfg(int iDeviceIndex, int iGroupNO = 0)
        {
            int  i = 0, j = 0;
            uint dwReturned = 0;
            int  dwSize     = 0;
            int  iLoopTime  = 0;

            if (g_deviceTree.g_struDeviceInfo[iDeviceIndex].iIPChanNum > 0)
            {
                if (g_deviceTree.g_struDeviceInfo[iDeviceIndex].iIPChanNum % (int)(CHCNetSDK.MAX_CHANNUM_V30) == 0)
                {
                    iLoopTime = g_deviceTree.g_struDeviceInfo[iDeviceIndex].iIPChanNum / (int)(CHCNetSDK.MAX_CHANNUM_V30);
                }
                else
                {
                    iLoopTime = g_deviceTree.g_struDeviceInfo[iDeviceIndex].iIPChanNum / (int)(CHCNetSDK.MAX_CHANNUM_V30) + 1;
                }
            }

            for (j = 0; j < iLoopTime; j++)
            {
                CHCNetSDK.NET_DVR_IPPARACFG_V40 struIPAccessCfgV40 = new CHCNetSDK.NET_DVR_IPPARACFG_V40();
                iGroupNO           = j;
                struIPAccessCfgV40 = g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruIPParaCfgV40[iGroupNO];
                dwSize             = Marshal.SizeOf(struIPAccessCfgV40);
                IntPtr ptrIPAccessCfgV40 = Marshal.AllocHGlobal(dwSize);
                Marshal.StructureToPtr(struIPAccessCfgV40, ptrIPAccessCfgV40, false);

                //2008-9-15 13:44 ip input configuration
                g_deviceTree.g_struDeviceInfo[iDeviceIndex].bIPRet =
                    CHCNetSDK.NET_DVR_GetDVRConfig(g_deviceTree.g_struDeviceInfo[iDeviceIndex].lLoginID, CHCNetSDK.NET_DVR_GET_IPPARACFG_V40, iGroupNO, ptrIPAccessCfgV40, (uint)dwSize, ref dwReturned);
                if (!g_deviceTree.g_struDeviceInfo[iDeviceIndex].bIPRet)
                {       ///device no support ip access
                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].lFirstEnableChanIndex = 0;
                    g_formList.AddLog(iDeviceIndex, AcsDemoPublic.OPERATION_FAIL_T, "NET_DVR_GET_IPPARACFG_V40");
                    i = j + iGroupNO * CHCNetSDK.MAX_CHANNUM_V30;
                    if (i < g_deviceTree.g_struDeviceInfo[iDeviceIndex].iAnalogChanNum)
                    {
                        g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i].iDeviceIndex = iDeviceIndex;
                        g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i].iChanIndex   = i;
                        g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i].iChannelNO   = i + g_deviceTree.g_struDeviceInfo[iDeviceIndex].iStartChan;
                        g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i].bEnable      = true;
                        g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i].iChanType    = AcsDemoPublic.DEMO_CHANNEL_TYPE.DEMO_CHANNEL_TYPE_ANALOG;
                        g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].pStruChanInfo[i].chChanName = string.Format("Camera{0}", i + g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].iStartChan);;
                    }
                    else//clear the state of other channel
                    {
                        g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i].iDeviceIndex = -1;
                        g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i].iChanIndex   = -1;
                        g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i].bEnable      = false;
                        g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].pStruChanInfo[i].chChanName = "";
                    }


                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO = -1;
                }
                else
                {
                    struIPAccessCfgV40 = (CHCNetSDK.NET_DVR_IPPARACFG_V40)Marshal.PtrToStructure(ptrIPAccessCfgV40, typeof(CHCNetSDK.NET_DVR_IPPARACFG_V40));
                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruIPParaCfgV40[iGroupNO] = struIPAccessCfgV40;
                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].iGroupNO = iGroupNO;
                    g_formList.AddLog(iDeviceIndex, AcsDemoPublic.OPERATION_SUCC_T, "NET_DVR_GET_IPPARACFG_V40");
                    RefreshIPDevLocalCfg(iDeviceIndex);
                }
                Marshal.FreeHGlobal(ptrIPAccessCfgV40);
            }

            for (i = 0; i < g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].iAnalogChanNum; i++)
            {
                g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].pStruChanInfo[i].iDeviceIndex = m_iDeviceIndex;
                g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].pStruChanInfo[i].iChanIndex   = i;
                g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].pStruChanInfo[i].iChannelNO   = i + g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].iStartChan;
                g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].pStruChanInfo[i].chChanName   = string.Format("Camera{0}", i + g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].iStartChan);

                g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].pStruChanInfo[i].bEnable     = true;
                g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i].iChanType     = AcsDemoPublic.DEMO_CHANNEL_TYPE.DEMO_CHANNEL_TYPE_ANALOG;
                g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].pStruChanInfo[i].dwImageType = AcsDemoPublic.CHAN_ORIGINAL;
            }

            if ((g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].byMirrorChanNum > 0) &&
                (g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].wStartMirrorChanNo > (g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].iDeviceChanNum - 1)))
            {
                for (i = 0; i < g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].byMirrorChanNum && i < 16; i++)
                {
                    g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].struMirrorChan[i].iDeviceIndex = m_iDeviceIndex;
                    g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].struMirrorChan[i].iChanIndex   = i + AcsDemoPublic.MIRROR_CHAN_INDEX;
                    g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].struMirrorChan[i].iChannelNO   = i + g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].wStartMirrorChanNo;
                    g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].struMirrorChan[i].chChanName   = string.Format("MirrorChan{0}", i + 1);

                    //analog devices
                    g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].struMirrorChan[i].bEnable     = true;
                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i].iChanType      = AcsDemoPublic.DEMO_CHANNEL_TYPE.DEMO_CHANNEL_TYPE_IP;
                    g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].struMirrorChan[i].dwImageType = AcsDemoPublic.CHAN_ORIGINAL;
                }
            }
            if (g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].byZeroChanNum > 0)
            {
                for (i = 0; i < g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].byZeroChanNum; i++)
                {
                    g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].struZeroChan[i].iDeviceIndex = m_iDeviceIndex;
                    g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].struZeroChan[i].iChanIndex   = i + AcsDemoPublic.ZERO_CHAN_INDEX;
                    g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].struZeroChan[i].chChanName   = string.Format("ZeroChan {0}", i);

                    g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].struZeroChan[i].bEnable     = true;
                    g_deviceTree.g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i].iChanType    = AcsDemoPublic.DEMO_CHANNEL_TYPE.DEMO_CHANNEL_TYPE_MIRROR;
                    g_deviceTree.g_struDeviceInfo[m_iDeviceIndex].struZeroChan[i].dwImageType = AcsDemoPublic.CHAN_ORIGINAL;
                }
            }
            return(g_deviceTree.g_struDeviceInfo[iDeviceIndex].bIPRet);
        }
Example #4
0
        /***获取通道***/
        public void GetDevChanList()
        {
            int    i = 0, j = 0;
            string str;

            m_struChanNoInfo.Init();

            if (m_struDeviceInfo.byIPChanNum > 0)
            {
                uint dwSize = (uint)Marshal.SizeOf(m_struIpParaCfgV40);

                IntPtr ptrIpParaCfgV40 = Marshal.AllocHGlobal((Int32)dwSize);
                Marshal.StructureToPtr(m_struIpParaCfgV40, ptrIpParaCfgV40, false);

                uint dwReturn = 0;
                if (!CHCNetSDK.NET_DVR_GetDVRConfig(m_lUserID, CHCNetSDK.NET_DVR_GET_IPPARACFG_V40, -1, ptrIpParaCfgV40, dwSize, ref dwReturn))
                {
                    iLastErr = CHCNetSDK.NET_DVR_GetLastError();
                    strErr   = "NET_DVR_GET_IPPARACFG_V40 failed, error code= " + iLastErr;
                    //获取IP通道信息失败,输出错误号 Failed to Get IP Channel info and output the error code
                    MessageBox.Show(strErr);
                }
                else
                {
                    m_struIpParaCfgV40 = (CHCNetSDK.NET_DVR_IPPARACFG_V40)Marshal.PtrToStructure(ptrIpParaCfgV40, typeof(CHCNetSDK.NET_DVR_IPPARACFG_V40));

                    //获取可用的模拟通道
                    for (i = 0; i < m_struIpParaCfgV40.dwAChanNum; i++)
                    {
                        if (m_struIpParaCfgV40.byAnalogChanEnable[i] == 1)
                        {
                            str = String.Format("通道{0}", i + 1);
                            comboBoxChan.Items.Add(str);
                            m_struChanNoInfo.lChannelNo[j] = i + m_struDeviceInfo.byStartChan;
                            j++;
                        }
                    }

                    //获取在线的IP通道
                    byte byStreamType;
                    for (i = 0; i < m_struIpParaCfgV40.dwDChanNum; i++)
                    {
                        byStreamType = m_struIpParaCfgV40.struStreamMode[i].byGetStreamType;
                        CHCNetSDK.NET_DVR_STREAM_MODE m_struStreamMode = new CHCNetSDK.NET_DVR_STREAM_MODE();
                        dwSize = (uint)Marshal.SizeOf(m_struStreamMode);
                        switch (byStreamType)
                        {
                        //0- 直接从设备取流 0- get stream from device directly
                        case 0:
                            IntPtr ptrChanInfo = Marshal.AllocHGlobal((Int32)dwSize);
                            Marshal.StructureToPtr(m_struIpParaCfgV40.struStreamMode[i].uGetStream, ptrChanInfo, false);
                            CHCNetSDK.NET_DVR_IPCHANINFO m_struChanInfo = new CHCNetSDK.NET_DVR_IPCHANINFO();
                            m_struChanInfo = (CHCNetSDK.NET_DVR_IPCHANINFO)Marshal.PtrToStructure(ptrChanInfo, typeof(CHCNetSDK.NET_DVR_IPCHANINFO));

                            //列出IP通道 List the IP channel
                            if (m_struChanInfo.byEnable == 1)
                            {
                                str = String.Format("IP通道{0}", i + 1);
                                comboBoxChan.Items.Add(str);
                                m_struChanNoInfo.lChannelNo[j] = i + (int)m_struIpParaCfgV40.dwStartDChan;
                                j++;
                            }
                            Marshal.FreeHGlobal(ptrChanInfo);
                            break;

                        //6- 直接从设备取流扩展 6- get stream from device directly(extended)
                        case 6:
                            IntPtr ptrChanInfoV40 = Marshal.AllocHGlobal((Int32)dwSize);
                            Marshal.StructureToPtr(m_struIpParaCfgV40.struStreamMode[i].uGetStream, ptrChanInfoV40, false);
                            CHCNetSDK.NET_DVR_IPCHANINFO_V40 m_struChanInfoV40 = new CHCNetSDK.NET_DVR_IPCHANINFO_V40();
                            m_struChanInfoV40 = (CHCNetSDK.NET_DVR_IPCHANINFO_V40)Marshal.PtrToStructure(ptrChanInfoV40, typeof(CHCNetSDK.NET_DVR_IPCHANINFO_V40));

                            //列出IP通道 List the IP channel
                            if (m_struChanInfoV40.byEnable == 1)
                            {
                                str = String.Format("IP通道{0}", i + 1);
                                comboBoxChan.Items.Add(str);
                                m_struChanNoInfo.lChannelNo[j] = i + (int)m_struIpParaCfgV40.dwStartDChan;
                                j++;
                            }
                            Marshal.FreeHGlobal(ptrChanInfoV40);
                            break;

                        default:
                            break;
                        }
                    }
                }
                Marshal.FreeHGlobal(ptrIpParaCfgV40);
            }
            else
            {
                for (i = 0; i < m_struDeviceInfo.byChanNum; i++)
                {
                    str = String.Format("通道{0}", i + 1);
                    comboBoxChan.Items.Add(str);
                    m_struChanNoInfo.lChannelNo[j] = i + m_struDeviceInfo.byStartChan;
                    j++;
                }
            }
            comboBoxChan.SelectedIndex = 0;
        }
Example #5
0
        public void RefreshIPDevLocalCfg(int iDeviceIndex)
        {
            CHCNetSDK.NET_DVR_IPPARACFG_V40 struIPAccessCfgV40 = g_struDeviceInfo[iDeviceIndex].pStruIPParaCfgV40[g_struDeviceInfo[iDeviceIndex].iGroupNO];
            uint dwChanShow   = 0;
            int  iIPChanIndex = 0;
            int  i            = 0;

            g_struDeviceInfo[iDeviceIndex].iIPChanNum = (int)struIPAccessCfgV40.dwDChanNum;

            int iAnalogChanCount = 0;
            int iIPChanCount     = 0;
            int iGroupNO         = g_struDeviceInfo[iDeviceIndex].iGroupNO; //Group NO.
            int iGroupNum        = (int)struIPAccessCfgV40.dwGroupNum;
            int iIPChanNum       = g_struDeviceInfo[iDeviceIndex].iIPChanNum;

            for (i = 0; i < CHCNetSDK.MAX_CHANNUM_V30; i++)
            {
                //analog channel
                if (iAnalogChanCount < g_struDeviceInfo[iDeviceIndex].iAnalogChanNum)
                {
                    dwChanShow = (uint)(iAnalogChanCount + g_struDeviceInfo[iDeviceIndex].iStartChan + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64);

                    g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iDeviceIndex = iDeviceIndex;
                    g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iChanIndex   = i;
                    g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iChanType    = CHCNetSDK.DEMO_CHANNEL_TYPE.DEMO_CHANNEL_TYPE_ANALOG;
                    g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iChannelNO   = (int)dwChanShow;

                    g_struDeviceInfo[m_iDeviceIndex].pStruChanInfo[i].chChanName =
                        string.Format("Camera{0}", i + g_struDeviceInfo[m_iDeviceIndex].iStartChan - g_struDeviceInfo[m_iDeviceIndex].iAnalogChanNum);
                    //analog devices
                    if (struIPAccessCfgV40.byAnalogChanEnable[i] > 0)
                    {
                        g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].bEnable     = true;
                        g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].dwImageType = CHCNetSDK.CHAN_ORIGINAL;
                        //g_struDeviceInfo[iDeviceIndex].iEnableChanNum ++;
                    }
                    else
                    {
                        g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].bEnable     = false;
                        g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].dwImageType = CHCNetSDK.CHAN_OFF_LINE;
                    }

                    iAnalogChanCount++;
                }
                else if (iGroupNO >= 0 && ((iIPChanCount + iGroupNO * CHCNetSDK.MAX_CHANNUM_V30) < iIPChanNum) && (iIPChanCount < iIPChanNum))
                {
                    byte enabeled = struIPAccessCfgV40.struIPDevInfo[i].byEnable;

                    dwChanShow = (uint)(iIPChanCount + iGroupNO * CHCNetSDK.MAX_CHANNUM_V30 + struIPAccessCfgV40.dwStartDChan);
                    g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iChanType  = CHCNetSDK.DEMO_CHANNEL_TYPE.DEMO_CHANNEL_TYPE_IP;
                    g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iChannelNO = (int)dwChanShow;
                    //if (i == 0)
                    //    StartDChan = (byte)dwChanShow;
                    iIPChanIndex = iIPChanCount;
                    g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iDeviceIndex = iDeviceIndex;
                    g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iChanIndex   = i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64;
                    //g_struDeviceInfo[m_iDeviceIndex].pStruChanInfo[i].chChanName =
                    //    string.Format("IPCamera{0}", iIPChanCount + iGroupNO * CHCNetSDK.MAX_CHANNUM_V30 + 1);
                    CHCNetSDK.NET_DVR_PICCFG_V30 m_struOsdCfg = getOSDConfig((int)dwChanShow);
                    //通道名称
                    if (enabeled == 1)
                    {//在线
                        if (!String.IsNullOrEmpty(m_struOsdCfg.sChanName))
                        {
                            g_struDeviceInfo[m_iDeviceIndex].pStruChanInfo[i].chChanName = getOSDConfig((int)dwChanShow).sChanName;
                        }
                        g_struDeviceInfo[m_iDeviceIndex].pStruChanInfo[i].bEnable = true;
                    }
                    else
                    {//离线
                        g_struDeviceInfo[m_iDeviceIndex].pStruChanInfo[i].chChanName =
                            string.Format("IPCamera{0}", iIPChanCount + iGroupNO * CHCNetSDK.MAX_CHANNUM_V30 + 1);
                        g_struDeviceInfo[m_iDeviceIndex].pStruChanInfo[i].bEnable = false;
                    }
                    //if (struIPAccessCfgV40.struStreamMode[iIPChanIndex].uGetStream.struChanInfo.byEnable != 0)  //struIPAccessCfgV40.struStreamMode[iIPChanIndex].uGetStream.struChanInfo.byIPID != 0 &&
                    //{
                    //    g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].bEnable = true;//
                    //    if (struIPAccessCfgV40.struStreamMode[iIPChanIndex].uGetStream.struChanInfo.byEnable > 0)
                    //    {
                    //        g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].dwImageType = CHCNetSDK.CHAN_ORIGINAL;
                    //    }
                    //    else
                    //    {
                    //        g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].dwImageType = CHCNetSDK.CHAN_OFF_LINE;
                    //    }
                    //    //				g_struDeviceInfo[iDeviceIndex].iEnableChanNum ++;
                    //}
                    //else
                    //{
                    //    g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].dwImageType = CHCNetSDK.CHAN_OFF_LINE;
                    //    g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].bEnable = false;
                    //    //g_struDeviceInfo[iDeviceIndex].struChanInfo[i].bAlarm = FALSE;
                    //}
                    iIPChanCount++;
                }
                else
                {
                    g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iDeviceIndex    = -1;
                    g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iChanIndex      = -1;
                    g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iChanType       = CHCNetSDK.DEMO_CHANNEL_TYPE.DEMO_CHANNEL_TYPE_INVALID;
                    g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].iChannelNO      = -1;
                    g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].bEnable         = false;
                    g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].bAlarm          = false;
                    g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].bLocalManualRec = false;
                    g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].lRealHandle     = -1;
                    g_struDeviceInfo[m_iDeviceIndex].pStruChanInfo[i].chChanName = "";
                }
            }

            for (i = 0; i < CHCNetSDK.MAX_CHANNUM_V40; i++)
            {
                if (g_struDeviceInfo[iDeviceIndex].pStruChanInfo[i + g_struDeviceInfo[iDeviceIndex].iGroupNO * 64].bEnable)
                {
                    g_struDeviceInfo[iDeviceIndex].lFirstEnableChanIndex = i;
                    break;
                }
            }
        }
Example #6
0
        /// <summary>
        /// 获取通道信息
        /// </summary>
        private void InfoIPChannel()
        {
            uint dwSize = (uint)Marshal.SizeOf(m_struIpParaCfgV40);

            IntPtr ptrIpParaCfgV40 = Marshal.AllocHGlobal((Int32)dwSize);

            Marshal.StructureToPtr(m_struIpParaCfgV40, ptrIpParaCfgV40, false);

            uint dwReturn = 0;
            int  iGroupNo = 0; //该Demo仅获取第一组64个通道,如果设备IP通道大于64路,需要按组号0~i多次调用NET_DVR_GET_IPPARACFG_V40获取

            if (!CHCNetSDK.NET_DVR_GetDVRConfig(m_lUserID, CHCNetSDK.NET_DVR_GET_IPPARACFG_V40, iGroupNo, ptrIpParaCfgV40, dwSize, ref dwReturn))
            {
                iLastErr = CHCNetSDK.NET_DVR_GetLastError();
                str      = "NET_DVR_GET_IPPARACFG_V40 failed, error code= " + iLastErr;
                //获取IP资源配置信息失败,输出错误号 Failed to get configuration of IP channels and output the error code
                throw new VideoPlayerException(str);
            }
            else
            {
                m_struIpParaCfgV40 = (CHCNetSDK.NET_DVR_IPPARACFG_V40)Marshal.PtrToStructure(ptrIpParaCfgV40, typeof(CHCNetSDK.NET_DVR_IPPARACFG_V40));

                byte byStreamType = 0;
                uint iDChanNum    = 64;

                if (dwDChanTotalNum < 64)
                {
                    iDChanNum = dwDChanTotalNum; //如果设备IP通道小于64路,按实际路数获取
                }

                for (i = 0; i < iDChanNum; i++)
                {
                    iChannelNum[i + dwAChanTotalNum] = i + (int)m_struIpParaCfgV40.dwStartDChan;
                    byStreamType = m_struIpParaCfgV40.struStreamMode[i].byGetStreamType;

                    dwSize = (uint)Marshal.SizeOf(m_struIpParaCfgV40.struStreamMode[i].uGetStream);
                    switch (byStreamType)
                    {
                    //目前NVR仅支持直接从设备取流 NVR supports only the mode: get stream from device directly
                    case 0:
                        IntPtr ptrChanInfo = Marshal.AllocHGlobal((Int32)dwSize);
                        Marshal.StructureToPtr(m_struIpParaCfgV40.struStreamMode[i].uGetStream, ptrChanInfo, false);
                        m_struChanInfo = (CHCNetSDK.NET_DVR_IPCHANINFO)Marshal.PtrToStructure(ptrChanInfo, typeof(CHCNetSDK.NET_DVR_IPCHANINFO));

                        iIPDevID[i] = m_struChanInfo.byIPID + m_struChanInfo.byIPIDHigh * 256 - iGroupNo * 64 - 1;

                        Marshal.FreeHGlobal(ptrChanInfo);
                        break;

                    case 6:
                        IntPtr ptrChanInfoV40 = Marshal.AllocHGlobal((Int32)dwSize);
                        Marshal.StructureToPtr(m_struIpParaCfgV40.struStreamMode[i].uGetStream, ptrChanInfoV40, false);
                        m_struChanInfoV40 = (CHCNetSDK.NET_DVR_IPCHANINFO_V40)Marshal.PtrToStructure(ptrChanInfoV40, typeof(CHCNetSDK.NET_DVR_IPCHANINFO_V40));
                        iIPDevID[i]       = m_struChanInfoV40.wIPID - iGroupNo * 64 - 1;

                        Marshal.FreeHGlobal(ptrChanInfoV40);
                        break;

                    default:
                        break;
                    }
                }
            }
            Marshal.FreeHGlobal(ptrIpParaCfgV40);
        }
Example #7
0
        public override bool Initialilize()
        {
            LastRunTime      = DateTime.Now.Ticks / 10000;
            struIpParaCfgV40 = new CHCNetSDK.NET_DVR_IPPARACFG_V40();
            struPicCfgV40    = new CHCNetSDK.NET_DVR_PICCFG_V40();
            m_struShowStrCfg = new CHCNetSDK.NET_DVR_SHOWSTRING_V30();
            Console.WriteLine("开始初始化");
            heartbeat.Interval = 60 * 1000 * 3;
            heartbeat.Elapsed -= Heartbeat_Elapsed;
            heartbeat.Elapsed += Heartbeat_Elapsed;
            heartbeat.Start();
            if (!Directory.Exists(AppDomain.CurrentDomain.BaseDirectory + "SdkLog\\"))
            {
                Directory.CreateDirectory(AppDomain.CurrentDomain.BaseDirectory + "SdkLog\\");
            }
            Config config = new Config(configpath)
            {
                GroupName = "service"
            };

            string[] host = config.GetSectionValues();
            if (NVRInfos == null)
            {
                CHCNetSDK.NET_DVR_SetLogToFile(0, AppDomain.CurrentDomain.BaseDirectory + "SdkLog\\", true);
                bool init = CHCNetSDK.NET_DVR_Init();
                if (!init)
                {
                    _log.Error("初始化失败" + CHCNetSDK.NET_DVR_GetLastError());
                    ErrorMsg = "初始化失败";
                    return(false);
                }

                bool retime = CHCNetSDK.NET_DVR_SetConnectTime(3000, 500);
                if (!retime)
                {
                    _log.Error("连接超时设置" + CHCNetSDK.NET_DVR_GetLastError());
                    ErrorMsg = "连接超时设置";
                }
                bool re = CHCNetSDK.NET_DVR_SetReconnect(3000, 1);
                if (!re)
                {
                    _log.Error("重连设置" + CHCNetSDK.NET_DVR_GetLastError());
                    ErrorMsg = "重连设置";
                }

                NVRInfos = new List <NVRInfo>();
            }
            for (int x = 0; x < host.Length; x++)
            {
                string name = host[x];
                config.Section = name;
                string ip       = config.GetValue("host", "ip", "192.168.2.1");
                int    port     = config.GetValue("host", "port", 8000);
                string username = config.GetValue("host", "username", "admin");
                string password = config.GetValue("host", "password", "ywwy2016");
                _log.Error(name + "." + x);
                NVRInfo nvr = NVRInfos.FirstOrDefault(o => o.Host.DVRIPAddress == ip);

                if (nvr == null)
                {
                    nvr = new NVRInfo()
                    {
                        Host = new NVRHostHiKv()
                        {
                            DVRIPAddress = ip, DVRPassword = password, DVRPort = port, DVRUserName = username, LUserId = -1
                        }, IPCs = new List <IPC>()
                    };
                }
                CHCNetSDK.NET_DVR_DEVICEINFO_V30 DeviceInfo = new CHCNetSDK.NET_DVR_DEVICEINFO_V30();
                int _login = -1;
                if (nvr.Host.LUserId > -1)
                {
                    _login = nvr.Host.LUserId;
                }
                else
                {
                    _login = CHCNetSDK.NET_DVR_Login_V30(ip, port, username, password, ref DeviceInfo);
                    Console.WriteLine(x + "登录" + _login);
                }

                if (_login >= 0)
                {
                    nvr.DeviceInfo   = DeviceInfo;
                    nvr.Host.LUserId = _login;
                    uint dwSize = (uint)Marshal.SizeOf(struIpParaCfgV40);

                    IntPtr ptrIpParaCfgV40 = Marshal.AllocHGlobal((Int32)dwSize);
                    Marshal.StructureToPtr(struIpParaCfgV40, ptrIpParaCfgV40, true);

                    uint dwReturn = 0;
                    int  iGroupNo = 0;
                    #region IPC通道
                    if (DeviceInfo.byIPChanNum > 0)
                    {
                        if (!CHCNetSDK.NET_DVR_GetDVRConfig(_login, CHCNetSDK.NET_DVR_GET_IPPARACFG_V40, iGroupNo, ptrIpParaCfgV40, dwSize, ref dwReturn))
                        {
                            ErrorMsg = "获取IPC失败." + CHCNetSDK.NET_DVR_GetLastError();
                            Console.WriteLine(ErrorMsg);
                            _log.Error(ErrorMsg);
                            Marshal.FreeHGlobal(ptrIpParaCfgV40);
                        }
                        else
                        {
                            struIpParaCfgV40 = (CHCNetSDK.NET_DVR_IPPARACFG_V40)Marshal.PtrToStructure(ptrIpParaCfgV40, typeof(CHCNetSDK.NET_DVR_IPPARACFG_V40));
                            CHCNetSDK.NET_DVR_IPDEVINFO_V31[] ipdevinfos = struIpParaCfgV40.struIPDevInfo;
                            #region 获取通道信息
                            for (int m = 0; m < ipdevinfos.Length; m++)
                            {
                                CHCNetSDK.NET_DVR_GET_STREAM_UNION unionGetStream = struIpParaCfgV40.struStreamMode[m].uGetStream;
                                uint   unSize      = (uint)Marshal.SizeOf(unionGetStream);
                                IntPtr ptrChanInfo = Marshal.AllocHGlobal((Int32)unSize);
                                Marshal.StructureToPtr(unionGetStream, ptrChanInfo, true);
                                CHCNetSDK.NET_DVR_IPCHANINFO struChanInfo = (CHCNetSDK.NET_DVR_IPCHANINFO)Marshal.PtrToStructure(ptrChanInfo, typeof(CHCNetSDK.NET_DVR_IPCHANINFO));
                                IPC ipc = new IPC()
                                {
                                    AdminPort = ipdevinfos[m].wDVRPort.ToString(), ChannelIndex = m + (int)struIpParaCfgV40.dwStartDChan, ChannelIp = ipdevinfos[m].struIP.sIpV4, ChannelName = "IPCamera" + m, Status = ipdevinfos[m].byEnable, UserName = Encoding.UTF8.GetString(ipdevinfos[m].sUserName).Trim('\0')
                                };
                                #region 获取通道名称
                                if (ipc.Status == 1)
                                {
                                    Int32  nSize     = Marshal.SizeOf(struPicCfgV40);
                                    IntPtr ptrPicCfg = Marshal.AllocHGlobal(nSize);
                                    Marshal.StructureToPtr(struPicCfgV40, ptrPicCfg, true);
                                    if (!CHCNetSDK.NET_DVR_GetDVRConfig(_login, CHCNetSDK.NET_DVR_GET_PICCFG_V40, ipc.ChannelIndex, ptrPicCfg, (UInt32)nSize, ref dwReturn))
                                    {
                                        ipc.ErrorMsg = CHCNetSDK.NET_DVR_GetLastError().ToString();
                                        ipc.Status   = 0;
                                        IPC oldipc = nvr.IPCs.FirstOrDefault(o => o.ChannelIp == ipc.ChannelIp);
                                        if (oldipc != null)
                                        {
                                            nvr.IPCs.Remove(oldipc);
                                        }
                                        nvr.IPCs.Add(ipc);
                                    }
                                    else
                                    {
                                        struPicCfgV40 = (CHCNetSDK.NET_DVR_PICCFG_V40)Marshal.PtrToStructure(ptrPicCfg, typeof(CHCNetSDK.NET_DVR_PICCFG_V40));
                                        if (struPicCfgV40.sChanName != null)
                                        {
                                            ipc.ChannelNumber = System.Text.Encoding.GetEncoding("GBK").GetString(struPicCfgV40.sChanName).Trim('\0');
                                        }
                                        ipc.Status = struChanInfo.byEnable;
                                        _log.Info("2:" + ipc.ChannelIndex + "." + ipc.ChannelIp + "." + struChanInfo.byEnable + "." + ipc.ChannelNumber);
                                        Console.WriteLine(ipc.ChannelIndex + "." + ipc.ChannelIp + "." + struChanInfo.byEnable + "." + ipc.ChannelNumber);
                                        IPC oldipc = nvr.IPCs.FirstOrDefault(o => o.ChannelIp == ipc.ChannelIp);
                                        if (oldipc != null)
                                        {
                                            nvr.IPCs.Remove(oldipc);
                                        }
                                        nvr.IPCs.Add(ipc);
                                    }
                                    Marshal.FreeHGlobal(ptrPicCfg);
                                }
                                #endregion
                                Marshal.FreeHGlobal(ptrChanInfo);
                            }
                            #endregion
                        }

                        NVRInfo oldnvr = NVRInfos.FirstOrDefault(o => o.Host.DVRIPAddress == ip);
                        if (nvr != null)
                        {
                            NVRInfos.Remove(oldnvr);
                        }
                        NVRInfos.Add(nvr);
                    }
                    #endregion
                    #region 其他通道
                    else
                    {
                        for (int i = 0; i < DeviceInfo.byChanNum; i++)
                        {
                            dwReturn = 0;

                            Int32  nSize     = Marshal.SizeOf(struPicCfgV40);
                            IntPtr ptrPicCfg = Marshal.AllocHGlobal(nSize);
                            Marshal.StructureToPtr(struPicCfgV40, ptrPicCfg, true);
                            int chancelid = i + DeviceInfo.byStartChan;
                            if (!CHCNetSDK.NET_DVR_GetDVRConfig(_login, CHCNetSDK.NET_DVR_GET_PICCFG_V40, chancelid, ptrPicCfg, (UInt32)nSize, ref dwReturn))
                            {
                                ErrorMsg = CHCNetSDK.NET_DVR_GetLastError().ToString();
                            }
                            else
                            {
                                struPicCfgV40 = (CHCNetSDK.NET_DVR_PICCFG_V40)Marshal.PtrToStructure(ptrPicCfg, typeof(CHCNetSDK.NET_DVR_PICCFG_V40));
                                IPC ipc = new IPC()
                                {
                                    AdminPort = "", ChannelIndex = chancelid, ChannelIp = nvr.Host.DVRIPAddress, ChannelName = "IPCamera" + i, Status = 1, ChannelNumber = System.Text.Encoding.GetEncoding("GBK").GetString(struPicCfgV40.sChanName).Trim('\0')
                                };

                                IPC oldipc = nvr.IPCs.FirstOrDefault(o => o.ChannelIp == ipc.ChannelIp);
                                if (oldipc != null)
                                {
                                    nvr.IPCs.Remove(oldipc);
                                }
                                nvr.IPCs.Add(ipc);
                            }
                            NVRInfo oldnvr = NVRInfos.FirstOrDefault(o => o.Host.DVRIPAddress == ip);
                            if (nvr != null)
                            {
                                NVRInfos.Remove(oldnvr);
                            }
                            NVRInfos.Add(nvr);
                            Marshal.FreeHGlobal(ptrPicCfg);
                        }
                    }
                    #endregion

                    Marshal.FreeHGlobal(ptrIpParaCfgV40);
                }
                else
                {
                    NVRInfo nvrerr = new NVRInfo()
                    {
                        Host = new NVRHostHiKv()
                        {
                            DVRIPAddress = ip, DVRPassword = password, DVRPort = port, DVRUserName = username, LUserId = -1
                        }, IPCs = new List <IPC>()
                    };

                    ErrorMsg             = "登录失败." + CHCNetSDK.NET_DVR_GetLastError();
                    nvrerr.Host.ErrorMsg = ErrorMsg;
                    Console.WriteLine(ErrorMsg);
                    _log.Error(ErrorMsg);
                    NVRInfo oldnvr = NVRInfos.FirstOrDefault(o => o.Host.DVRIPAddress == ip);
                    if (nvr != null)
                    {
                        NVRInfos.Remove(oldnvr);
                    }
                    NVRInfos.Add(nvrerr);
                }
            }
            GC.Collect();
            GC.WaitForPendingFinalizers();
            Console.WriteLine("完成初始化");

            return(true);
        }
Example #8
0
        public OResult <IEnumerable <CameraChannel> > GetChannels()
        {
            UInt32 dwReturn        = 0;
            var    iGroupNo        = 0; //0表示仅获取第一组64个通道,如果设备IP通道大于64路,需要按组号0~i多次调用NET_DVR_GET_IPPARACFG_V40获取
            var    iIPDevID        = new Int32[96];
            var    dwAChanTotalNum = (UInt32)_deviceInfo.struDeviceV30.byChanNum;
            var    dwDChanTotalNum = (UInt32)(_deviceInfo.struDeviceV30.byIPChanNum + 256 * _deviceInfo.struDeviceV30.byHighDChanNum);
            IntPtr ptrIpParaCfgV40 = IntPtr.Zero;
            var    channels        = new List <CameraChannel>(16);

            try
            {
                if (dwDChanTotalNum > 0)
                {
                    var m_struIpParaCfgV40 = new CHCNetSDK.NET_DVR_IPPARACFG_V40();
                    var dwSize             = (UInt32)Marshal.SizeOf(m_struIpParaCfgV40);

                    ptrIpParaCfgV40 = Marshal.AllocHGlobal((Int32)dwSize);
                    Marshal.StructureToPtr(m_struIpParaCfgV40, ptrIpParaCfgV40, false);

                    if (CHCNetSDK.NET_DVR_GetDVRConfig(_userId, CHCNetSDK.NET_DVR_GET_IPPARACFG_V40, iGroupNo, ptrIpParaCfgV40, dwSize, ref dwReturn))
                    {
                        m_struIpParaCfgV40 = (CHCNetSDK.NET_DVR_IPPARACFG_V40)Marshal.PtrToStructure(ptrIpParaCfgV40, typeof(CHCNetSDK.NET_DVR_IPPARACFG_V40));

                        if (dwAChanTotalNum > 0)
                        {
                            for (var i = 0; i < dwAChanTotalNum; i++)
                            {
                                channels.Add(new CameraChannel()
                                {
                                    ChannelNo   = _deviceInfo.struDeviceV30.byStartChan + i,
                                    ChannelType = (Int32)CameraChannelType.AC,
                                    IsEnabled   = m_struIpParaCfgV40.byAnalogChanEnable[i] != 0
                                });
                            }
                        }

                        UInt32 iDChanNum = 64;
                        if (dwDChanTotalNum < 64)
                        {
                            iDChanNum = dwDChanTotalNum; //如果设备IP通道小于64路,按实际路数获取
                        }

                        CHCNetSDK.NET_DVR_IPCHANINFO     m_struChanInfo;
                        CHCNetSDK.NET_DVR_PU_STREAM_URL  m_struStreamURL;
                        CHCNetSDK.NET_DVR_IPCHANINFO_V40 m_struChanInfoV40;

                        if (iDChanNum > 0)
                        {
                            for (var i = 0; i < iDChanNum; i++)
                            {
                                var byStreamType = m_struIpParaCfgV40.struStreamMode[i].byGetStreamType;
                                dwSize = (UInt32)Marshal.SizeOf(m_struIpParaCfgV40.struStreamMode[i].uGetStream);

                                var dcChannel = new CameraChannel()
                                {
                                    ChannelNo   = (Int32)m_struIpParaCfgV40.dwStartDChan + i,
                                    ChannelType = (Int32)CameraChannelType.DC
                                };

                                switch (byStreamType)
                                {
                                //目前NVR仅支持直接从设备取流
                                case 0:
                                    IntPtr ptrChanInfo = Marshal.AllocHGlobal((Int32)dwSize);
                                    Marshal.StructureToPtr(m_struIpParaCfgV40.struStreamMode[i].uGetStream, ptrChanInfo, false);
                                    m_struChanInfo = (CHCNetSDK.NET_DVR_IPCHANINFO)Marshal.PtrToStructure(ptrChanInfo, typeof(CHCNetSDK.NET_DVR_IPCHANINFO));
                                    UpdateChannel(ref dcChannel, m_struChanInfo.byEnable, m_struChanInfo.byIPID);
                                    iIPDevID[i] = m_struChanInfo.byIPID + m_struChanInfo.byIPIDHigh * 256 - iGroupNo * 64 - 1;
                                    Marshal.FreeHGlobal(ptrChanInfo);
                                    break;

                                case 4:
                                    IntPtr ptrStreamURL = Marshal.AllocHGlobal((Int32)dwSize);
                                    Marshal.StructureToPtr(m_struIpParaCfgV40.struStreamMode[i].uGetStream, ptrStreamURL, false);
                                    m_struStreamURL = (CHCNetSDK.NET_DVR_PU_STREAM_URL)Marshal.PtrToStructure(ptrStreamURL, typeof(CHCNetSDK.NET_DVR_PU_STREAM_URL));
                                    UpdateChannel(ref dcChannel, m_struStreamURL.byEnable, m_struStreamURL.wIPID);
                                    iIPDevID[i] = m_struStreamURL.wIPID - iGroupNo * 64 - 1;
                                    Marshal.FreeHGlobal(ptrStreamURL);
                                    break;

                                case 6:
                                    IntPtr ptrChanInfoV40 = Marshal.AllocHGlobal((Int32)dwSize);
                                    Marshal.StructureToPtr(m_struIpParaCfgV40.struStreamMode[i].uGetStream, ptrChanInfoV40, false);
                                    m_struChanInfoV40 = (CHCNetSDK.NET_DVR_IPCHANINFO_V40)Marshal.PtrToStructure(ptrChanInfoV40, typeof(CHCNetSDK.NET_DVR_IPCHANINFO_V40));
                                    UpdateChannel(ref dcChannel, m_struChanInfoV40.byEnable, m_struChanInfoV40.wIPID);
                                    iIPDevID[i] = m_struChanInfoV40.wIPID - iGroupNo * 64 - 1;
                                    Marshal.FreeHGlobal(ptrChanInfoV40);
                                    break;

                                default:
                                    break;
                                }

                                channels.Add(dcChannel);
                            }
                        }
                    }
                }
                else
                {
                    for (var i = 0; i < dwAChanTotalNum; i++)
                    {
                        channels.Add(new CameraChannel()
                        {
                            ChannelNo   = _deviceInfo.struDeviceV30.byStartChan + i,
                            ChannelType = (Int32)CameraChannelType.AC,
                            IsEnabled   = true
                        });
                    }
                }

                return(new OResult <IEnumerable <CameraChannel> >(channels));
            }
            finally
            {
                Marshal.FreeHGlobal(ptrIpParaCfgV40);
            }
        }
        public void InfoIPChannel()
        {
            uint dwSize = (uint)Marshal.SizeOf(m_struIpParaCfgV40);

            IntPtr ptrIpParaCfgV40 = Marshal.AllocHGlobal((Int32)dwSize);

            Marshal.StructureToPtr(m_struIpParaCfgV40, ptrIpParaCfgV40, false);

            uint dwReturn = 0;
            int  iGroupNo = 0;

            if (!CHCNetSDK.NET_DVR_GetDVRConfig(camera_id, CHCNetSDK.NET_DVR_GET_IPPARACFG_V40, iGroupNo, ptrIpParaCfgV40, dwSize, ref dwReturn))
            {
                iLastErr = CHCNetSDK.NET_DVR_GetLastError();
                str      = "NET_DVR_GET_IPPARACFG_V40 failed, error code= " + iLastErr;
                //获取IP资源配置信息失败,输出错误号 Failed to get configuration of IP channels and output the error code
                DebugInfo(str);
            }
            else
            {
                DebugInfo("NET_DVR_GET_IPPARACFG_V40 succ!");

                m_struIpParaCfgV40 = (CHCNetSDK.NET_DVR_IPPARACFG_V40)Marshal.PtrToStructure(ptrIpParaCfgV40, typeof(CHCNetSDK.NET_DVR_IPPARACFG_V40));

                for (i = 0; i < dwAChanTotalNum; i++)
                {
                    ListAnalogChannel(i + 1, m_struIpParaCfgV40.byAnalogChanEnable[i]);
                    iChannelNum[i] = i + (int)DeviceInfo_top.byStartChan;
                }

                byte byStreamType;
                for (i = 0; i < m_struIpParaCfgV40.dwDChanNum; i++)
                {
                    iChannelNum[i + dwAChanTotalNum] = i + (int)m_struIpParaCfgV40.dwStartDChan;
                    byStreamType = m_struIpParaCfgV40.struStreamMode[i].byGetStreamType;

                    dwSize = (uint)Marshal.SizeOf(m_struIpParaCfgV40.struStreamMode[i].uGetStream);
                    switch (byStreamType)
                    {
                    //目前NVR仅支持直接从设备取流 NVR supports only the mode: get stream from device directly
                    case 0:
                        IntPtr ptrChanInfo = Marshal.AllocHGlobal((Int32)dwSize);
                        Marshal.StructureToPtr(m_struIpParaCfgV40.struStreamMode[i].uGetStream, ptrChanInfo, false);
                        m_struChanInfo = (CHCNetSDK.NET_DVR_IPCHANINFO)Marshal.PtrToStructure(ptrChanInfo, typeof(CHCNetSDK.NET_DVR_IPCHANINFO));

                        //列出IP通道 List the IP channel
                        ListIPChannel(i + 1, m_struChanInfo.byEnable, m_struChanInfo.byIPID);
                        iIPDevID[i] = m_struChanInfo.byIPID + m_struChanInfo.byIPIDHigh * 256 - iGroupNo * 64 - 1;

                        Marshal.FreeHGlobal(ptrChanInfo);
                        break;

                    case 6:
                        IntPtr ptrChanInfoV40 = Marshal.AllocHGlobal((Int32)dwSize);
                        Marshal.StructureToPtr(m_struIpParaCfgV40.struStreamMode[i].uGetStream, ptrChanInfoV40, false);
                        m_struChanInfoV40 = (CHCNetSDK.NET_DVR_IPCHANINFO_V40)Marshal.PtrToStructure(ptrChanInfoV40, typeof(CHCNetSDK.NET_DVR_IPCHANINFO_V40));

                        //列出IP通道 List the IP channel
                        ListIPChannel(i + 1, m_struChanInfoV40.byEnable, m_struChanInfoV40.wIPID);
                        iIPDevID[i] = m_struChanInfoV40.wIPID - iGroupNo * 64 - 1;

                        Marshal.FreeHGlobal(ptrChanInfoV40);
                        break;

                    default:
                        break;
                    }
                }
            }
            Marshal.FreeHGlobal(ptrIpParaCfgV40);
        }
Example #10
0
        private void InfoIpChannel()
        {
            var dwSize = (uint)Marshal.SizeOf(_struIpParaCfgV40);

            var ptrIpParaCfgV40 = Marshal.AllocHGlobal((int)dwSize);

            Marshal.StructureToPtr(_struIpParaCfgV40, ptrIpParaCfgV40, false);

            uint      dwReturn = 0;
            const int iGroupNo = 0; //该Demo仅获取第一组64个通道,如果设备IP通道大于64路,需要按组号0~i多次调用NET_DVR_GET_IPPARACFG_V40获取

            if (!CHCNetSDK.NET_DVR_GetDVRConfig(_loginUserId, CHCNetSDK.NET_DVR_GET_IPPARACFG_V40, iGroupNo, ptrIpParaCfgV40, dwSize, ref dwReturn))
            {
                _lastError = CHCNetSDK.NET_DVR_GetLastError();
                DisplayMessage($"获取录像机通道信息失败。错误码{_lastError}");
                return;
            }
            _struIpParaCfgV40 = (CHCNetSDK.NET_DVR_IPPARACFG_V40)Marshal.PtrToStructure(ptrIpParaCfgV40, typeof(CHCNetSDK.NET_DVR_IPPARACFG_V40));

            for (var i = 0; i < _dwAChanTotalNum; i++)
            {
                _iChannelNum[i] = i + _deviceInfo.byStartChan;
            }

            uint iDChanNum = 64;

            if (_dwDChanTotalNum < 64)
            {
                iDChanNum = _dwDChanTotalNum; //如果设备IP通道小于64路,按实际路数获取
            }

            for (var i = 0; i < iDChanNum; i++)
            {
                _iChannelNum[i + _dwAChanTotalNum] = i + (int)_struIpParaCfgV40.dwStartDChan;
                var byStreamType = _struIpParaCfgV40.struStreamMode[i].byGetStreamType;

                dwSize = (uint)Marshal.SizeOf(_struIpParaCfgV40.struStreamMode[i].uGetStream);
                switch (byStreamType)
                {
                //目前NVR仅支持直接从设备取流 NVR supports only the mode: get stream from device directly
                case 0:
                    var ptrChanInfo = Marshal.AllocHGlobal((int)dwSize);
                    Marshal.StructureToPtr(_struIpParaCfgV40.struStreamMode[i].uGetStream, ptrChanInfo, false);
                    _struChanInfo = (CHCNetSDK.NET_DVR_IPCHANINFO)Marshal.PtrToStructure(ptrChanInfo, typeof(CHCNetSDK.NET_DVR_IPCHANINFO));

                    _iIpDevId[i] = _struChanInfo.byIPID + (_struChanInfo.byIPIDHigh * 256) - (iGroupNo * 64) - 1;

                    Marshal.FreeHGlobal(ptrChanInfo);
                    break;

                case 6:
                    var ptrChanInfoV40 = Marshal.AllocHGlobal((int)dwSize);
                    Marshal.StructureToPtr(_struIpParaCfgV40.struStreamMode[i].uGetStream, ptrChanInfoV40, false);
                    _struChanInfoV40 = (CHCNetSDK.NET_DVR_IPCHANINFO_V40)Marshal.PtrToStructure(ptrChanInfoV40, typeof(CHCNetSDK.NET_DVR_IPCHANINFO_V40));

                    _iIpDevId[i] = _struChanInfoV40.wIPID - (iGroupNo * 64) - 1;

                    Marshal.FreeHGlobal(ptrChanInfoV40);
                    break;
                }
            }
            Marshal.FreeHGlobal(ptrIpParaCfgV40);
            DisplayMessage("控件初始化完成,可以启动预览。");
        }
Example #11
0
        public void Query_CameraStatus_Info(Action <string> sendCameraStatus)
        {
            //Stopwatch sp = new Stopwatch();
            //sp.Start();
            if (!isLoaddeviceInfo)
            {
                return;
            }
            StationList station = deviceInfo.StationList.Find(_ => _.PStationID == null);

            if (station == null)
            {
                return;
            }
            cameraStatusList.Clear();

            //LogServerManager.AddRunLog(OperationType.System, "查询本级摄像机状态");
            Dictionary <string, HikSdkManager.UserID_m_lAlarmHandle> userIDDic = hikSdkManager.GetUserIDDic();
            List <Task> taskList = new List <Task>();

            foreach (var streamMedia in deviceInfo.StreamMediaList.Where(_ => _.StationID == station.StationID))
            {
                taskList.Add(Task.Run(() =>
                {
                    bool isGetDVRConfig    = false;
                    bool isGetDVRWorkstate = false;
                    if (!userIDDic.ContainsKey(streamMedia.VideoIP))//设备未登陆成功
                    {
                        foreach (var camera in deviceInfo.CameraList.FindAll(_ => _.StreamMedia_DeviceID == streamMedia.DeviceID))
                        {
                            CameraStatusList newCameraStatus = new CameraStatusList();
                            newCameraStatus.DeviceID         = camera.DeviceID;
                            newCameraStatus.Name             = camera.VideoName;
                            newCameraStatus.IsOnline         = false;
                            newCameraStatus.Time             = DateTime.Now;
                            cameraStatusList.Add(newCameraStatus);
                        }
                        //continue;
                    }
                    else
                    {
                        HikSdkManager.UserID_m_lAlarmHandle userInfo = userIDDic[streamMedia.VideoIP];
                        uint dwDChanTotalNum = (uint)userInfo.deviceInfo.byIPChanNum + 256 * (uint)userInfo.deviceInfo.byHighDChanNum;
                        #region 旧的设备状态需求
                        //uint dwSize = (uint)Marshal.SizeOf(m_struIpParaCfgV40);
                        //IntPtr ptrIpParaCfgV40 = Marshal.AllocHGlobal((Int32)dwSize);
                        //Marshal.StructureToPtr(m_struIpParaCfgV40, ptrIpParaCfgV40, false);
                        //uint dwReturn = 0;
                        //int iGroupNo = 0;  //该Demo仅获取第一组64个通道,如果设备IP通道大于64路,需要按组号0~i多次调用NET_DVR_GET_IPPARACFG_V40获取
                        //if (!CHCNetSDK.NET_DVR_GetDVRConfig(userInfo.UserID, CHCNetSDK.NET_DVR_GET_IPPARACFG_V40, iGroupNo, ptrIpParaCfgV40, dwSize, ref dwReturn))
                        //{
                        //    uint iLastErr = CHCNetSDK.NET_DVR_GetLastError();
                        //    string errContent = "NET_DVR_GET_IPPARACFG_V40 failed, error code= " + iLastErr;
                        //    //获取IP资源配置信息失败,输出错误号 Failed to get configuration of IP channels and output the error code
                        //    LogServerManager.AddErrLog(ErrLogType.InterfaceErr, null, this.GetType().ToString(), "Query_CameraStatus_Info", errContent);
                        //}
                        //else
                        //{
                        //    m_struIpParaCfgV40 = (CHCNetSDK.NET_DVR_IPPARACFG_V40)Marshal.PtrToStructure(ptrIpParaCfgV40, typeof(CHCNetSDK.NET_DVR_IPPARACFG_V40));
                        //    uint dwAChanTotalNum = (uint)userInfo.deviceInfo.byChanNum;
                        //    uint dwDChanTotalNum = (uint)userInfo.deviceInfo.byIPChanNum + 256 * (uint)userInfo.deviceInfo.byHighDChanNum;
                        //    if (dwDChanTotalNum > 0)
                        //    {
                        //        byte byStreamType = 0;
                        //        foreach (var camera in deviceInfo.CameraList.FindAll(_ => _.StreamMedia_DeviceID == streamMedia.DeviceID))
                        //        {
                        //            int videoChannel = camera.VideoChannel - 33;//实际通道号
                        //            byStreamType = m_struIpParaCfgV40.struStreamMode[videoChannel].byGetStreamType;
                        //            dwSize = (uint)Marshal.SizeOf(m_struIpParaCfgV40.struStreamMode[videoChannel].uGetStream);
                        //            CameraStatusList newCameraStatus = new CameraStatusList();
                        //            switch (byStreamType)
                        //            {
                        //                //目前NVR仅支持直接从设备取流 NVR supports only the mode: get stream from device directly
                        //                case 0:
                        //                    IntPtr ptrChanInfo = Marshal.AllocHGlobal((Int32)dwSize);
                        //                    Marshal.StructureToPtr(m_struIpParaCfgV40.struStreamMode[videoChannel].uGetStream, ptrChanInfo, false);
                        //                    m_struChanInfo = (CHCNetSDK.NET_DVR_IPCHANINFO)Marshal.PtrToStructure(ptrChanInfo, typeof(CHCNetSDK.NET_DVR_IPCHANINFO));

                        //                    dwSize = (uint)Marshal.SizeOf(m_struCompressionCfgV30);
                        //                    IntPtr ptrCompressionCfgV30 = Marshal.AllocHGlobal((Int32)dwSize);
                        //                    Marshal.StructureToPtr(m_struCompressionCfgV30, ptrCompressionCfgV30, false);
                        //                    CHCNetSDK.NET_DVR_COMPRESSION_INFO_V30 m_struCompressionInfoV30 = new CHCNetSDK.NET_DVR_COMPRESSION_INFO_V30();
                        //                    if (!CHCNetSDK.NET_DVR_GetDVRConfig(userInfo.UserID, CHCNetSDK.NET_DVR_GET_COMPRESSCFG_V30, camera.VideoChannel, ptrCompressionCfgV30, dwSize, ref dwReturn))
                        //                    {
                        //                        uint iLastErr = CHCNetSDK.NET_DVR_GetLastError();
                        //                        string errContent = "NET_DVR_GET_COMPRESSCFG_V30 failed, error code= " + iLastErr;
                        //                        //获取IP资源配置信息失败,输出错误号 Failed to get configuration of IP channels and output the error code
                        //                        LogServerManager.AddErrLog(ErrLogType.InterfaceErr, null, this.GetType().ToString(), "Query_CameraStatus_Info", errContent);
                        //                    }
                        //                    else
                        //                    {
                        //                        m_struCompressionCfgV30 = (CHCNetSDK.NET_DVR_COMPRESSIONCFG_V30)Marshal.PtrToStructure(ptrCompressionCfgV30, typeof(CHCNetSDK.NET_DVR_COMPRESSIONCFG_V30));
                        //                        m_struCompressionInfoV30 = m_struCompressionCfgV30.struNormHighRecordPara;
                        //                    }
                        //                    newCameraStatus.DeviceID = camera.DeviceID;
                        //                    newCameraStatus.Name = camera.VideoName;
                        //                    //newCameraStatus.IsOnline = BitConverter.ToBoolean(new byte[] { m_struChanInfo.byEnable }, 0);
                        //                    //newCameraStatus.NetStatus = newCameraStatus.IsOnline;
                        //                    //newCameraStatus.ImgStatus = newCameraStatus.IsOnline ? 2 : 0;
                        //                    //newCameraStatus.ImgQuality = m_struCompressionInfoV30.byPicQuality;
                        //                    //newCameraStatus.BitStream = bitStreamDic[m_struCompressionInfoV30.dwVideoBitrate];
                        //                    newCameraStatus.Time = DateTime.Now;
                        //                    cameraStatusList.Add(newCameraStatus);

                        //                    Marshal.FreeHGlobal(ptrChanInfo);
                        //                    break;
                        //                case 6:
                        //                    IntPtr ptrChanInfoV40 = Marshal.AllocHGlobal((Int32)dwSize);
                        //                    Marshal.StructureToPtr(m_struIpParaCfgV40.struStreamMode[videoChannel].uGetStream, ptrChanInfoV40, false);
                        //                    m_struChanInfoV40 = (CHCNetSDK.NET_DVR_IPCHANINFO_V40)Marshal.PtrToStructure(ptrChanInfoV40, typeof(CHCNetSDK.NET_DVR_IPCHANINFO_V40));

                        //                    Marshal.FreeHGlobal(ptrChanInfoV40);
                        //                    break;
                        //                default:
                        //                    break;
                        //            }
                        //        }
                        //    }
                        //    else
                        //    {
                        //        foreach (var camera in deviceInfo.CameraList.FindAll(_ => _.StreamMedia_DeviceID == streamMedia.DeviceID))
                        //        {
                        //            CameraStatusList newCameraStatus = new CameraStatusList();
                        //            newCameraStatus.DeviceID = camera.DeviceID;
                        //            newCameraStatus.Name = camera.VideoName;
                        //            //newCameraStatus.IsOnline = true;
                        //            //newCameraStatus.NetStatus = newCameraStatus.IsOnline;
                        //            //newCameraStatus.ImgStatus = 0;
                        //            //newCameraStatus.ImgQuality = 0;
                        //            newCameraStatus.Time = DateTime.Now;
                        //            cameraStatusList.Add(newCameraStatus);
                        //        }
                        //    }
                        //}
                        #endregion

                        CHCNetSDK.NET_DVR_IPPARACFG_V40 m_struIpParaCfgV40 = new CHCNetSDK.NET_DVR_IPPARACFG_V40();
                        uint dwSizeIpParaCfgV40 = (uint)Marshal.SizeOf(m_struIpParaCfgV40);
                        IntPtr ptrIpParaCfgV40  = Marshal.AllocHGlobal((Int32)dwSizeIpParaCfgV40);
                        Marshal.StructureToPtr(m_struIpParaCfgV40, ptrIpParaCfgV40, false);
                        uint dwReturn = 0;
                        int iGroupNo  = 0;       //该Demo仅获取第一组64个通道,如果设备IP通道大于64路,需要按组号0~i多次调用NET_DVR_GET_IPPARACFG_V40获取

                        if (dwDChanTotalNum > 0) //数字通道
                        {
                            if (!CHCNetSDK.NET_DVR_GetDVRConfig(userInfo.UserID, CHCNetSDK.NET_DVR_GET_IPPARACFG_V40, iGroupNo, ptrIpParaCfgV40, dwSizeIpParaCfgV40, ref dwReturn))
                            {
                                uint iLastErr     = CHCNetSDK.NET_DVR_GetLastError();
                                string errContent = "NET_DVR_GET_IPPARACFG_V40 failed, error code= " + iLastErr;
                                //获取IP资源配置信息失败,输出错误号 Failed to get configuration of IP channels and output the error code
                                LogServerManager.AddErrLog(ErrLogType.InterfaceErr, null, this.GetType().ToString(), "Query_CameraStatus_Info", errContent);
                                isGetDVRConfig = false;
                            }
                            else
                            {
                                m_struIpParaCfgV40 = (CHCNetSDK.NET_DVR_IPPARACFG_V40)Marshal.PtrToStructure(ptrIpParaCfgV40, typeof(CHCNetSDK.NET_DVR_IPPARACFG_V40));
                                Marshal.FreeHGlobal(ptrIpParaCfgV40);
                                isGetDVRConfig = true;
                            }
                        }

                        CHCNetSDK.NET_DVR_WORKSTATE_V30 struDvrWorkstate = new CHCNetSDK.NET_DVR_WORKSTATE_V30();
                        uint dwSizeDvrWorkstate = (uint)Marshal.SizeOf(struDvrWorkstate);
                        IntPtr ptrDvrWorkstate  = Marshal.AllocHGlobal((int)dwSizeDvrWorkstate);
                        Marshal.StructureToPtr(struDvrWorkstate, ptrDvrWorkstate, false);
                        if (!CHCNetSDK.NET_DVR_GetDVRWorkState_V30(userInfo.UserID, ptrDvrWorkstate))
                        {
                            uint iLastErr     = CHCNetSDK.NET_DVR_GetLastError();
                            string errContent = "NET_DVR_GetDVRWorkState_V30 failed, error code= " + iLastErr;
                            //获取IP资源配置信息失败,输出错误号 Failed to get configuration of IP channels and output the error code
                            LogServerManager.AddErrLog(ErrLogType.InterfaceErr, null, this.GetType().ToString(), "Query_CameraStatus_Info", errContent);
                            isGetDVRWorkstate = false;
                        }
                        else
                        {
                            struDvrWorkstate = (CHCNetSDK.NET_DVR_WORKSTATE_V30)Marshal.PtrToStructure(ptrDvrWorkstate, typeof(CHCNetSDK.NET_DVR_WORKSTATE_V30));
                            Marshal.FreeHGlobal(ptrDvrWorkstate);
                            isGetDVRWorkstate = true;
                        }

                        foreach (var camera in deviceInfo.CameraList.FindAll(_ => _.StreamMedia_DeviceID == streamMedia.DeviceID))
                        {
                            int channelNum = camera.VideoChannel - 1;
                            CameraStatusList newCameraStatus = new CameraStatusList();
                            newCameraStatus.DeviceID         = camera.DeviceID;
                            newCameraStatus.Name             = camera.VideoName;
                            if (dwDChanTotalNum > 0 && isGetDVRConfig)         //有数字通道且获取到了配置信息
                            {
                                int videoChannel   = camera.VideoChannel - 33; //实际通道号
                                byte byStreamType  = m_struIpParaCfgV40.struStreamMode[videoChannel].byGetStreamType;
                                uint dwSizeStream  = (uint)Marshal.SizeOf(m_struIpParaCfgV40.struStreamMode[videoChannel].uGetStream);
                                IntPtr ptrChanInfo = Marshal.AllocHGlobal((int)dwSizeStream);
                                Marshal.StructureToPtr(m_struIpParaCfgV40.struStreamMode[videoChannel].uGetStream, ptrChanInfo, false);
                                CHCNetSDK.NET_DVR_IPCHANINFO m_struChanInfo = (CHCNetSDK.NET_DVR_IPCHANINFO)Marshal.PtrToStructure(ptrChanInfo, typeof(CHCNetSDK.NET_DVR_IPCHANINFO));
                                newCameraStatus.IsOnline = BitConverter.ToBoolean(new byte[] { m_struChanInfo.byEnable }, 0);
                                Marshal.FreeHGlobal(ptrChanInfo);
                            }
                            else if (dwDChanTotalNum > 0 && !isGetDVRConfig)//有数字通道但未获取到了配置信息
                            {
                                newCameraStatus.IsOnline = false;
                            }
                            else//模拟通道默认都在线
                            {
                                newCameraStatus.IsOnline = true;
                            }
                            if (isGetDVRWorkstate)
                            {
                                newCameraStatus.RecordStatus   = struDvrWorkstate.struChanStatic[channelNum].byRecordStatic + 1;
                                newCameraStatus.SignalStatus   = struDvrWorkstate.struChanStatic[channelNum].bySignalStatic + 1;
                                newCameraStatus.HardwareStatus = struDvrWorkstate.struChanStatic[channelNum].byHardwareStatic + 1;
                                newCameraStatus.BitRate        = (int)struDvrWorkstate.struChanStatic[channelNum].dwBitRate;
                            }
                            newCameraStatus.Time = DateTime.Now;
                            cameraStatusList.Add(newCameraStatus);
                        }
                    }
                }));
            }

            Task.WaitAll(taskList.ToArray());
            string jsonContent = JsonConvert.SerializeObject(cameraStatusList);
            sendCameraStatus(jsonContent);

            //sp.Stop();
            //Console.WriteLine(sp.Elapsed);
        }
Example #12
0
        public void InfoIPChannel()
        {
            uint dwSize = (uint)Marshal.SizeOf(m_struIpParaCfgV40);

            IntPtr ptrIpParaCfgV40 = Marshal.AllocHGlobal((Int32)dwSize);

            Marshal.StructureToPtr(m_struIpParaCfgV40, ptrIpParaCfgV40, false);

            uint dwReturn = 0;
            int  iGroupNo = 0;

            if (!CHCNetSDK.NET_DVR_GetDVRConfig(m_lUserID, CHCNetSDK.NET_DVR_GET_IPPARACFG_V40, iGroupNo, ptrIpParaCfgV40, dwSize, ref dwReturn))
            {
                iLastErr = CHCNetSDK.NET_DVR_GetLastError();
                str      = "NET_DVR_GET_IPPARACFG_V40 failed, error code= " + iLastErr;

                DebugInfo(str);
            }
            else
            {
                DebugInfo("NET_DVR_GET_IPPARACFG_V40 succ!");

                m_struIpParaCfgV40 = (CHCNetSDK.NET_DVR_IPPARACFG_V40)Marshal.PtrToStructure(ptrIpParaCfgV40, typeof(CHCNetSDK.NET_DVR_IPPARACFG_V40));



                byte byStreamType = 0;
                uint iDChanNum    = 64;

                if (dwDChanTotalNum < 64)
                {
                    iDChanNum = dwDChanTotalNum;
                }

                for (i = 0; i < iDChanNum; i++)
                {
                    iChannelNum[i + dwAChanTotalNum] = i + (int)m_struIpParaCfgV40.dwStartDChan;
                    byStreamType = m_struIpParaCfgV40.struStreamMode[i].byGetStreamType;

                    dwSize = (uint)Marshal.SizeOf(m_struIpParaCfgV40.struStreamMode[i].uGetStream);
                    switch (byStreamType)
                    {
                    case 0:
                        IntPtr ptrChanInfo = Marshal.AllocHGlobal((Int32)dwSize);
                        Marshal.StructureToPtr(m_struIpParaCfgV40.struStreamMode[i].uGetStream, ptrChanInfo, false);
                        m_struChanInfo = (CHCNetSDK.NET_DVR_IPCHANINFO)Marshal.PtrToStructure(ptrChanInfo, typeof(CHCNetSDK.NET_DVR_IPCHANINFO));



                        iIPDevID[i] = m_struChanInfo.byIPID + m_struChanInfo.byIPIDHigh * 256 - iGroupNo * 64 - 1;

                        Marshal.FreeHGlobal(ptrChanInfo);
                        break;

                    case 6:
                        IntPtr ptrChanInfoV40 = Marshal.AllocHGlobal((Int32)dwSize);
                        Marshal.StructureToPtr(m_struIpParaCfgV40.struStreamMode[i].uGetStream, ptrChanInfoV40, false);
                        m_struChanInfoV40 = (CHCNetSDK.NET_DVR_IPCHANINFO_V40)Marshal.PtrToStructure(ptrChanInfoV40, typeof(CHCNetSDK.NET_DVR_IPCHANINFO_V40));



                        iIPDevID[i] = m_struChanInfoV40.wIPID - iGroupNo * 64 - 1;

                        Marshal.FreeHGlobal(ptrChanInfoV40);
                        break;

                    default:
                        break;
                    }
                }
            }
            Marshal.FreeHGlobal(ptrIpParaCfgV40);
        }