flute 1.11.0

File Delivery over Unidirectional Transport (FLUTE)
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use crate::common::{
    alc,
    oti::{self, SchemeSpecific},
};
use crate::error::FluteError;
use crate::fec;
use crate::fec::nocode;
use crate::fec::rscodec;
use crate::fec::FecDecoder;
use crate::tools::error::Result;

#[derive(Debug)]
pub struct BlockDecoder {
    pub completed: bool,
    pub initialized: bool,
    pub block_size: usize,
    decoder: Option<Box<dyn FecDecoder>>,
}

impl BlockDecoder {
    pub fn new() -> BlockDecoder {
        BlockDecoder {
            completed: false,
            initialized: false,
            decoder: None,
            block_size: 0,
        }
    }

    pub fn init(
        &mut self,
        oti: &oti::Oti,
        nb_source_symbols: u32,
        block_size: usize,
        sbn: u32,
    ) -> Result<()> {
        if self.initialized {
            return Ok(());
        }

        match oti.fec_encoding_id {
            oti::FECEncodingID::NoCode => {
                let codec = nocode::NoCodeDecoder::new(nb_source_symbols as usize);
                self.decoder = Some(Box::new(codec));
            }
            oti::FECEncodingID::ReedSolomonGF28 => {
                let codec = rscodec::RSGalois8Codec::new(
                    nb_source_symbols as usize,
                    oti.max_number_of_parity_symbols as usize,
                    oti.encoding_symbol_length as usize,
                )?;
                self.decoder = Some(Box::new(codec));
            }
            oti::FECEncodingID::ReedSolomonGF28UnderSpecified => {
                let codec = rscodec::RSGalois8Codec::new(
                    nb_source_symbols as usize,
                    oti.max_number_of_parity_symbols as usize,
                    oti.encoding_symbol_length as usize,
                )?;
                self.decoder = Some(Box::new(codec));
            }
            oti::FECEncodingID::ReedSolomonGF2M => {
                log::warn!("Not implemented")
            }
            oti::FECEncodingID::RaptorQ => {
                if let Some(SchemeSpecific::RaptorQ(scheme)) = oti.scheme_specific.as_ref() {
                    let codec = fec::raptorq::RaptorQDecoder::new(
                        sbn,
                        nb_source_symbols as usize,
                        oti.encoding_symbol_length as usize,
                        scheme,
                    );
                    self.decoder = Some(Box::new(codec));
                } else {
                    return Err(FluteError::new("RaptorQ Scheme not found"));
                }
            }
            oti::FECEncodingID::Raptor => {
                if oti.scheme_specific.is_none() {
                    return Err(FluteError::new("Raptor Scheme not found"));
                }

                let codec = fec::raptor::RaptorDecoder::new(nb_source_symbols as usize, block_size);
                self.decoder = Some(Box::new(codec));
            }
        }

        self.initialized = true;
        self.block_size = block_size;
        Ok(())
    }

    pub fn source_block(&self) -> Result<&[u8]> {
        if self.decoder.is_none() {
            return Err(FluteError::new("Fail to decode block"));
        }

        self.decoder.as_ref().unwrap().source_block()
    }

    pub fn deallocate(&mut self) {
        self.decoder = None;
        self.block_size = 0;
    }

    pub fn push(&mut self, pkt: &alc::AlcPkt, payload_id: &alc::PayloadID) {
        debug_assert!(self.initialized);

        if self.completed {
            return;
        }

        debug_assert!(self.decoder.is_some());
        if self.decoder.is_none() {
            log::error!("Decoder has been deallocated");
            return;
        }

        let payload = &pkt.data[pkt.data_payload_offset..];
        let decoder = self.decoder.as_mut().unwrap();
        decoder.push_symbol(payload, payload_id.esi);

        if decoder.can_decode() {
            self.completed = decoder.decode();
            if self.completed {
                log::debug!("Block completed");
            }
        }
    }
}