GPU idx 变更

pansen

2019-02-25 8d1ead663449e6bf508d4d703b6d56381141daeb

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
#ifndef HCDOWNLOADELEMENT_XZL_201808091137
#define HCDOWNLOADELEMENT_XZL_201808091137
 
#include "myThread.h"
#include "HCNetSDK.h"
#include "HcRecord.h"
#include "HcAnalysVideo.h"
#include <mutex>
 
 
class HcDowloadElement : public mythread<ChannelLoadFileManage> {
    using TASK_FUNCTION = std::function<void(std::shared_ptr<ChannelLoadFileManage> &)>;
public:
    HcDowloadElement(const TASK_FUNCTION task_f = nullptr) : m_task_function(task_f) {}
//    HcDowloadElement(LDBTool* dbTool) : m_fileManage(dbTool) {
//        m_HcRecord.init("192.168.1.4", 8000, "admin", "basic123");
//    }
 
//    HcDowloadElement(HcAnalysVideo *p) : m_HcAnalysVideo(p) {
//        m_HcRecord.init("192.168.1.4", 8000, "admin", "basic123");
//    }
 
    void addDevice(const std::string strDevID, const char *ip,
                   const unsigned short port,
                   const char *usrname,
                   const char *passwd) {
        //#todo
        if (m_mapHcRecord.find(strDevID) == m_mapHcRecord.end()) {
            m_mapHcRecord[strDevID] = new HcRecord;
            m_mapHcRecord[strDevID]->init(ip, port, usrname, passwd);
        } else {
            ERR("设备已存在");
        }
 
    }
 
    ~HcDowloadElement() {
//        m_HcRecord.unInit();
        for (auto item : m_mapHcRecord) {
            item.second->unInit();
            delete (item.second);
        }
    }
 
 
private:
 
    virtual void doFunc(std::shared_ptr<ChannelLoadFileManage> spPacket) {
        if (m_mapHcRecord.find(spPacket->strDevID) == m_mapHcRecord.end()) {
            ERR("设备不已存在");
            return;
        }
//        std::vector<int> ret = m_HcRecord.getUsefulChans();
        std::vector<int> ret = m_mapHcRecord[spPacket->strDevID]->getUsefulChans();
        NET_DVR_TIME startTime;
        startTime.dwYear = spPacket->startTime.Year;
        startTime.dwMonth = spPacket->startTime.Month;
        startTime.dwDay = spPacket->startTime.Day;
        startTime.dwHour = spPacket->startTime.Hour;
        startTime.dwMinute = spPacket->startTime.Minute;
        startTime.dwSecond = spPacket->startTime.Second;
        NET_DVR_TIME endTime;
        endTime.dwYear = spPacket->endTime.Year;
        endTime.dwMonth = spPacket->endTime.Month;
        endTime.dwDay = spPacket->endTime.Day;
        endTime.dwHour = spPacket->endTime.Hour;
        endTime.dwMinute = spPacket->endTime.Minute;
        endTime.dwSecond = spPacket->endTime.Second;
        std::string filePath;
        //#todo 任务按照30min的颗粒度拆分。
        m_mapHcRecord[spPacket->strDevID]->downloadfiles(spPacket->strDevID.c_str(), spPacket->nChannelID, &startTime,
                                                         &endTime, filePath);
        if (m_task_function != nullptr) {
            auto str = filePath.substr(0, filePath.rfind('/'));
            spPacket->srcPath = filePath.substr(0, filePath.rfind('/'));
            DBG(spPacket->srcPath);
            m_task_function(spPacket);
        } else {
            ERR("m_task_function == nullptr");
            return;
        }
    }
 
private:
//    HcRecord m_HcRecord;
    std::map<std::string, HcRecord *> m_mapHcRecord;
    TASK_FUNCTION m_task_function;
//    HcAnalysVideo *m_HcAnalysVideo;
//    loadFileManage m_fileManage;
};
 
#endif