jt1078 0.1.0

jt1078协议库实现
Documentation 
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use chrono::{Local, TimeZone};
use jt808::models::{Jt808, Jt808BodySerialize, Jt808BodyTrans, Ver808};
use jt_util::{
    bytes::{IBuffRead, IBuffWrite},
};

#[derive(Debug, Default)]
pub struct Jt0x1205 {
    /// 流水号（对应查询音视频资源列表指令的流水号）
    pub sn: u16,
    // /// 音视频资源总数（无符合条件的音视频资源，置为0）
    // pub file_count: u32,
    /// 音视频资源列表
    pub file_list: Vec<JtVideoFileListItem>,
}

impl Jt808BodySerialize for Jt0x1205 {
    fn write(&mut self, ver: &Ver808, buf: &mut dyn IBuffWrite) {
        buf.put_u16(self.sn);
        buf.put_u32(self.file_list.len() as u32);

        for item in self.file_list.iter_mut() {
            item.write(ver, buf);
        }
    }

    fn len(&self, _ver: &Ver808) -> usize {
        6 + self.file_list.len() * 28
    }
}

impl Jt808BodyTrans for Jt0x1205 {
    fn fill_new<T>(buf: &mut T, jt808: &Jt808) -> Self
    where
        T: IBuffRead,
    {
        let sn = buf.get_u16();
        let file_count = buf.get_u32() as usize;
        let mut file_list = Vec::<JtVideoFileListItem>::with_capacity(file_count);
        for _i in 0..file_count {
            file_list.push(JtVideoFileListItem::fill_new(buf, jt808));
        }

        Self { sn, file_list }
    }
}

#[derive(Debug, Default)]
pub struct JtVideoFileListItem {
    /// 逻辑通道号
    pub channel: u8,
    /// 开始时间
    pub starttime: i64,
    /// 结束时间
    pub endtime: i64,
    /// 报警标志（bit0~bit31见JT/T 808-2011表18报警标志位定义；bit32~bit64见表13；全0表示无报警类型条件）
    pub alarm: u64,
    /// 音视频资源类型（0：音视频，1：音频，2：视频，3：视频或音视频）
    pub media_type: u8,
    /// 码流类型（0：所有码流，1：主码流，2：子码流）
    pub stream_type: u8,
    /// 存储器类型（0：所有存储器，1：主存储器，2：灾备存储器）
    pub storage_type: u8,
    /// 文件大小（单字节BYTE）
    pub file_size: u32,
}

impl Jt808BodySerialize for JtVideoFileListItem {
    fn write(&mut self, _ver: &Ver808, buf: &mut dyn IBuffWrite) {
        buf.put_u8(self.channel);
        if self.starttime == 0 {
            buf.put_slice(&[0; 6]);
        } else {
            buf.put_dt_bcd6(Local.timestamp(self.starttime, 0));
        }
        if self.endtime == 0 {
            buf.put_slice(&[0; 6]);
        } else {
            buf.put_dt_bcd6(Local.timestamp(self.endtime, 0));
        }
        buf.put_u64(self.alarm);
        buf.put_u8(self.media_type);
        buf.put_u8(self.stream_type);
        buf.put_u8(self.storage_type);
        buf.put_u32(self.file_size);
    }

    fn len(&self, _ver: &Ver808) -> usize {
        28
    }
}

impl Jt808BodyTrans for JtVideoFileListItem {
    fn fill_new<T>(buf: &mut T, _jt808: &Jt808) -> Self
    where
        T: IBuffRead,
    {
        Self {
            channel: buf.get_u8(),
            starttime: buf.get_dt_bcd6_timestamp(),
            endtime: buf.get_dt_bcd6_timestamp(),
            alarm: buf.get_u64(),
            media_type: buf.get_u8(),
            stream_type: buf.get_u8(),
            storage_type: buf.get_u8(),
            file_size: buf.get_u32(),
        }
    }
}