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