jt1078 0.1.0

pub trait IJtRtpHead {
    fn set_m(&mut self, value: bool);
    /// 负载类型
    fn set_pt(&mut self, value: u8);
    /// 包序号
    fn set_sn(&mut self, value: u16);
    //sim卡号
    fn set_sim(&mut self, value: String);
    //通道号
    fn set_channel(&mut self, value: u8);

    fn set_xxxx(&mut self, value: u8);
    fn set_yyyy(&mut self, value: u8);
    ///时间戳
    fn set_time_stamp(&mut self, value: u64);
    ///关键帧
    fn set_last_i_ts(&mut self, value: u16);
    fn set_last_ts(&mut self, value: u16);
    //后续长度
    fn set_dlen(&mut self, value: u16);
    fn get_head_len(&self) -> usize;
    fn get_buf(&self) -> &[u8];
}

#[derive(Debug)]
pub struct JtRtpHeadv13 {
    buff: [u8; 30],
    m: bool,
    pt: u8,
    sn: u16,
    sim: String,
    channel: u8,
    xxxx: u8,
    yyyy: u8,
    time_stamp: u64,
    last_i_ts: u16,
    last_ts: u16,
    dlen: u16,
}

impl JtRtpHeadv13 {
    pub fn new() -> Self {
        let buff = [
            0x30, 0x31, 0x63, 0x64, 0x81, 0x62, 0x00, 0x00, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
            0x01, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x00, 0x00, 0x00, 0x00, 0x03, 0xB6,
        ];

        JtRtpHeadv13 {
            buff,
            m: false,
            pt: 98,
            sn: 0,
            sim: "111111111111".to_string(),
            channel: 1,
            xxxx: 0,
            yyyy: 1,
            time_stamp: 0,
            last_i_ts: 0,
            last_ts: 0,
            dlen: 950,
        }
    }
}

impl IJtRtpHead for JtRtpHeadv13 {
    fn set_m(&mut self, value: bool) {
        if self.m != value {
            self.buff[5] = (self.buff[5] & 0x7F)
                | match value {
                    true => 0x80,
                    false => 0,
                };
            self.m = value;
        }
    }
    /// 负载类型
    fn set_pt(&mut self, value: u8) {
        if self.pt != value {
            self.buff[5] = (self.buff[5] & 0x80) | (value & 0x7F);
            self.pt = value;
        }
    }
    /// 包序号
    fn set_sn(&mut self, value: u16) {
        if self.sn != value {
            let b = value.to_be_bytes();
            self.buff[6..8].copy_from_slice(&b);
            self.sn = value;
        }
    }
    //sim卡号
    fn set_sim(&mut self, value: String) {
        if self.sim != value {
            let mut bcd = jt_util::bytes_bcd::BytesBCD::default();
            bcd.set_val(&value, 12);
            self.buff[8..14].copy_from_slice(&bcd.get_bytes());
            self.sim = value;
        }
    }
    //通道号
    fn set_channel(&mut self, value: u8) {
        if self.channel != value {
            self.buff[14] = value;
            self.channel = value;
        }
    }

    fn set_xxxx(&mut self, value: u8) {
        if self.xxxx != value {
            self.buff[15] = (self.buff[15] & 0xF) | ((value & 0xF) << 4);
            if self.xxxx < 3 && value >= 3 {
                self.set_dlen(0);
            }
            self.xxxx = value;
        }
    }
    fn set_yyyy(&mut self, value: u8) {
        if self.yyyy != value {
            self.buff[15] = (self.buff[15] & 0xF0) | (value & 0xf);
            self.yyyy = value;
        }
    }
    ///时间戳
    fn set_time_stamp(&mut self, value: u64) {
        if self.time_stamp != value && self.xxxx < 4 {
            let b = value.to_be_bytes();
            self.buff[16..24].copy_from_slice(&b);
            self.time_stamp = value;
        }
    }
    ///关键帧
    fn set_last_i_ts(&mut self, value: u16) {
        if self.last_i_ts != value && self.xxxx < 3 {
            let b = value.to_be_bytes();
            self.buff[24..26].copy_from_slice(&b);
            self.last_i_ts = value;
        }
    }
    fn set_last_ts(&mut self, value: u16) {
        if self.last_ts != value && self.xxxx < 3 {
            let b = value.to_be_bytes();
            self.buff[26..28].copy_from_slice(&b);
            self.last_ts = value;
        }
    }
    //后续长度
    fn set_dlen(&mut self, value: u16) {
        if self.dlen != value {
            let b = value.to_be_bytes();
            if self.xxxx < 3 {
                self.buff[28..30].copy_from_slice(&b);
            } else if self.xxxx == 3 {
                self.buff[24..26].copy_from_slice(&b);
            } else {
                self.buff[16..18].copy_from_slice(&b);
            }
            self.dlen = value;
        }
    }
    fn get_head_len(&self) -> usize {
        if self.xxxx < 3 {
            30
        } else if self.xxxx == 3 {
            26
        } else {
            18
        }
    }
    fn get_buf(&self) -> &[u8] {
        &self.buff[..self.get_head_len()]
    }
}

#[derive(Debug)]
pub struct JtRtpHeadv19 {
    buff: [u8; 34],
    m: bool,
    pt: u8,
    sn: u16,
    sim: String,
    channel: u8,
    xxxx: u8,
    yyyy: u8,
    time_stamp: u64,
    last_i_ts: u16,
    last_ts: u16,
    dlen: u16,
}

impl JtRtpHeadv19 {
    pub fn new() -> Self {
        let buff = [
            0x30, 0x31, 0x63, 0x64, 0x81, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x11,
            0x11, 0x11, 0x11, 0x11, 0x01, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x00, 0x00,
            0x00, 0x00, 0x03, 0xB6,
        ];

        JtRtpHeadv19 {
            buff,
            m: false,
            pt: 98,
            sn: 0,
            sim: "0000111111111111".to_string(),
            channel: 1,
            xxxx: 0,
            yyyy: 1,
            time_stamp: 0,
            last_i_ts: 0,
            last_ts: 0,
            dlen: 950,
        }
    }
}

impl IJtRtpHead for JtRtpHeadv19 {
    fn set_m(&mut self, value: bool) {
        if self.m != value {
            self.buff[5] = (self.buff[5] & 0x7F)
                | match value {
                    true => 0x80,
                    false => 0,
                };
            self.m = value;
        }
    }
    /// 负载类型
    fn set_pt(&mut self, value: u8) {
        if self.pt != value {
            self.buff[5] = (self.buff[5] & 0x80) | (value & 0x7F);
            self.pt = value;
        }
    }
    /// 包序号
    fn set_sn(&mut self, value: u16) {
        if self.sn != value {
            let b = value.to_be_bytes();
            self.buff[6..8].copy_from_slice(&b);
            self.sn = value;
        }
    }
    //sim卡号
    fn set_sim(&mut self, value: String) {
        if self.sim != value {
            let mut bcd = jt_util::bytes_bcd::BytesBCD::default();
            bcd.set_val(&value, 20);
            self.buff[8..18].copy_from_slice(&bcd.get_bytes());
            self.sim = value;
        }
    }
    //通道号
    fn set_channel(&mut self, value: u8) {
        if self.channel != value {
            self.buff[18] = value;
            self.channel = value;
        }
    }

    fn set_xxxx(&mut self, value: u8) {
        if self.xxxx != value {
            self.buff[19] = (self.buff[19] & 0xF) | ((value & 0xF) << 4);
            if self.xxxx < 3 && value >= 3 {
                self.set_dlen(0);
            }
            self.xxxx = value;
        }
    }
    fn set_yyyy(&mut self, value: u8) {
        if self.yyyy != value {
            self.buff[19] = (self.buff[19] & 0xF0) | (value & 0xf);
            self.yyyy = value;
        }
    }
    ///时间戳
    fn set_time_stamp(&mut self, value: u64) {
        if self.time_stamp != value && self.xxxx < 4 {
            let b = value.to_be_bytes();
            self.buff[20..28].copy_from_slice(&b);
            self.time_stamp = value;
        }
    }
    ///关键帧
    fn set_last_i_ts(&mut self, value: u16) {
        if self.last_i_ts != value && self.xxxx < 3 {
            let b = value.to_be_bytes();
            self.buff[28..30].copy_from_slice(&b);
            self.last_i_ts = value;
        }
    }
    fn set_last_ts(&mut self, value: u16) {
        if self.last_ts != value && self.xxxx < 3 {
            let b = value.to_be_bytes();
            self.buff[30..32].copy_from_slice(&b);
            self.last_ts = value;
        }
    }
    //后续长度
    fn set_dlen(&mut self, value: u16) {
        if self.dlen != value {
            let b = value.to_be_bytes();
            if self.xxxx < 3 {
                self.buff[32..34].copy_from_slice(&b);
            } else if self.xxxx == 3 {
                self.buff[28..30].copy_from_slice(&b);
            } else {
                self.buff[20..22].copy_from_slice(&b);
            }
            self.dlen = value;
        }
    }
    fn get_head_len(&self) -> usize {
        if self.xxxx < 3 {
            34
        } else if self.xxxx == 3 {
            30
        } else {
            22
        }
    }
    fn get_buf(&self) -> &[u8] {
        &self.buff[..self.get_head_len()]
    }
}

#[derive(Debug)]
pub struct JtRtpHead {
    v19: bool,
    buff: [u8; 34],
    m: bool,
    pt: u8,
    sn: u16,
    sim: String,
    channel: u8,
    xxxx: u8,
    yyyy: u8,
    time_stamp: u64,
    last_i_ts: u16,
    last_ts: u16,
    dlen: u16,
}

impl JtRtpHead {
    pub fn new(v19: bool) -> Self {
        let (buff, sim) = if v19 {
            (
                [
                    0x30, 0x31, 0x63, 0x64, 0x81, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11,
                    0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
                    0x0, 0x00, 0x00, 0x00, 0x00, 0x03, 0xB6,
                ],
                "0000111111111111".to_string(),
            )
        } else {
            (
                [
                    0x30, 0x31, 0x63, 0x64, 0x81, 0x62, 0x00, 0x00, 0x11, 0x11, 0x11, 0x11, 0x11,
                    0x11, 0x01, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x00, 0x00, 0x00,
                    0x00, 0x03, 0xB6, 0x00, 0x00, 0x00, 0x00,
                ],
                "111111111111".to_string(),
            )
        };

        JtRtpHead {
            v19,
            buff,
            m: false,
            pt: 98,
            sn: 0,
            sim: sim,
            channel: 1,
            xxxx: 0,
            yyyy: 1,
            time_stamp: 0,
            last_i_ts: 0,
            last_ts: 0,
            dlen: 950,
        }
    }
    pub fn set_m(&mut self, value: bool) {
        if self.m != value {
            self.buff[5] = (self.buff[5] & 0x7F)
                | match value {
                    true => 0x80,
                    false => 0,
                };
            self.m = value;
        }
    }
    /// 负载类型
    pub fn set_pt(&mut self, value: u8) {
        if self.pt != value {
            self.buff[5] = (self.buff[5] & 0x80) | (value & 0x7F);
            self.pt = value;
        }
    }
    /// 包序号
    pub fn set_sn(&mut self, value: u16) {
        if self.sn != value {
            let b = value.to_be_bytes();
            self.buff[6..8].copy_from_slice(&b);
            self.sn = value;
        }
    }
    //sim卡号
    pub fn set_sim(&mut self, value: String) {
        if self.sim != value {
            let mut bcd = jt_util::bytes_bcd::BytesBCD::default();
            if self.v19 {
                bcd.set_val(&value, 20);
                self.buff[8..18].copy_from_slice(&bcd.get_bytes());
            } else {
                bcd.set_val(&value, 12);
                self.buff[8..14].copy_from_slice(&bcd.get_bytes());
            }
            self.sim = value;
        }
    }
    //通道号
    pub fn set_channel(&mut self, value: u8) {
        if self.channel != value {
            if self.v19 {
                self.buff[18] = value;
            } else {
                self.buff[14] = value;
            }
            self.channel = value;
        }
    }

    pub fn set_xxxx(&mut self, value: u8) {
        if self.xxxx != value {
            if self.v19 {
                self.buff[19] = (self.buff[19] & 0xF) | ((value & 0xF) << 4);
            } else {
                self.buff[15] = (self.buff[15] & 0xF) | ((value & 0xF) << 4);
            }
            if self.xxxx < 3 && value >= 3 {
                self.set_dlen(0);
            }
            self.xxxx = value;
        }
    }
    pub fn set_yyyy(&mut self, value: u8) {
        if self.yyyy != value {
            if self.v19 {
                self.buff[19] = (self.buff[19] & 0xF0) | (value & 0xf);
            } else {
                self.buff[15] = (self.buff[15] & 0xF0) | (value & 0xf);
            }
            self.yyyy = value;
        }
    }
    ///时间戳
    pub fn set_time_stamp(&mut self, value: u64) {
        if self.time_stamp != value && self.xxxx < 4 {
            let b = value.to_be_bytes();

            if self.v19 {
                self.buff[20..28].copy_from_slice(&b);
            } else {
                self.buff[16..24].copy_from_slice(&b);
            }
            self.time_stamp = value;
        }
    }
    ///关键帧
    pub fn set_last_i_ts(&mut self, value: u16) {
        if self.last_i_ts != value && self.xxxx < 3 {
            let b = value.to_be_bytes();
            if self.v19 {
                self.buff[28..30].copy_from_slice(&b);
            } else {
                self.buff[24..26].copy_from_slice(&b);
            }
            self.last_i_ts = value;
        }
    }
    pub fn set_last_ts(&mut self, value: u16) {
        if self.last_ts != value && self.xxxx < 3 {
            let b = value.to_be_bytes();
            if self.v19 {
                self.buff[30..32].copy_from_slice(&b);
            } else {
                self.buff[26..28].copy_from_slice(&b);
            }
            self.last_ts = value;
        }
    }
    //后续长度
    pub fn set_dlen(&mut self, value: u16) {
        if self.dlen != value {
            let b = value.to_be_bytes();
            if self.xxxx < 3 {
                if self.v19 {
                    self.buff[32..34].copy_from_slice(&b);
                } else {
                    self.buff[28..30].copy_from_slice(&b);
                }
            } else if self.xxxx == 3 {
                if self.v19 {
                    self.buff[28..30].copy_from_slice(&b);
                } else {
                    self.buff[24..26].copy_from_slice(&b);
                }
            } else {
                if self.v19 {
                    self.buff[20..22].copy_from_slice(&b);
                } else {
                    self.buff[16..18].copy_from_slice(&b);
                }
            }
            self.dlen = value;
        }
    }
    pub fn get_head_len(&self) -> usize {
        if self.v19 {
            if self.xxxx < 3 {
                34
            } else if self.xxxx == 3 {
                30
            } else {
                22
            }
        } else {
            if self.xxxx < 3 {
                30
            } else if self.xxxx == 3 {
                26
            } else {
                18
            }
        }
    }
    pub fn get_buf(&self) -> &[u8] {
        &self.buff[..self.get_head_len()]
    }
}