1 use bytes::BytesMut; 2 3 //5.3.1.1 4 #[derive(Eq, PartialEq, Debug, Clone)] 5 pub struct ChunkBasicHeader { 6 pub format: u8, 7 pub chunk_stream_id: u32, 8 } 9 10 impl ChunkBasicHeader { 11 pub fn new(fmt: u8, csid: u32) -> ChunkBasicHeader { 12 ChunkBasicHeader { 13 format: fmt, 14 chunk_stream_id: csid, 15 } 16 } 17 } 18 19 //5.3.1.2 20 #[derive(Eq, PartialEq, Debug, Clone)] 21 pub struct ChunkMessageHeader { 22 pub timestamp: u32, 23 pub msg_length: u32, 24 pub msg_type_id: u8, 25 pub msg_streamd_id: u32, 26 pub timestamp_delta: u32, 27 pub is_extended_timestamp: bool, 28 } 29 30 impl ChunkMessageHeader { 31 pub fn new(timestamp: u32, msg_length: u32, msg_type_id: u8, msg_stream_id: u32) -> Self { 32 Self { 33 timestamp: timestamp, 34 msg_length: msg_length, 35 msg_type_id: msg_type_id, 36 msg_streamd_id: msg_stream_id, 37 timestamp_delta: 0, 38 is_extended_timestamp: false, 39 } 40 } 41 } 42 43 pub struct ChunkHeader { 44 pub basic_header: ChunkBasicHeader, 45 pub message_header: ChunkMessageHeader, 46 } 47 48 impl ChunkHeader { 49 pub fn new() -> ChunkHeader { 50 ChunkHeader { 51 basic_header: ChunkBasicHeader::new(0, 0), 52 message_header: ChunkMessageHeader::new(0, 0, 0, 0), 53 } 54 } 55 } 56 57 // pub struct Chunk { 58 // basic_header: ChunkBasicHeader, 59 // message_header: ChunkMessageHeader, 60 // raw_data: BytesMut, 61 // } 62 63 #[derive(Eq, PartialEq, Debug, Clone)] 64 pub struct ChunkInfo { 65 pub basic_header: ChunkBasicHeader, 66 pub message_header: ChunkMessageHeader, 67 pub payload: BytesMut, 68 } 69 impl ChunkInfo { 70 pub fn new( 71 csid: u32, 72 format: u8, 73 timestamp: u32, 74 msg_length: u32, 75 msg_type_id: u8, 76 msg_stream_id: u32, 77 payload: BytesMut, 78 ) -> Self { 79 Self { 80 basic_header: ChunkBasicHeader::new(format, csid), 81 message_header: ChunkMessageHeader::new( 82 timestamp, 83 msg_length, 84 msg_type_id, 85 msg_stream_id, 86 ), 87 payload: payload, 88 } 89 } 90 91 pub fn default() -> ChunkInfo { 92 ChunkInfo::new(0, 0, 0, 0, 0, 0, BytesMut::new()) 93 } 94 } 95 96 // impl Chunk { 97 // pub fn chunk_read(&mut self, bytes: &[u8]) -> Result { 98 // self.buffer.extend_from_slice(bytes); 99 // } 100 101 // pub fn read_basic_header(&mut self, bytes: &[u8]) -> Result<UnpackResult, ChunkUnpackError> { 102 // if self.buffer.len() < 1 { 103 // return Ok(UnpackResult::NotEnoughBytes); 104 // } 105 // } 106 // } 107