Merge pull request #20 from quasipaas/dev

睡觉，暂时更新部分；

Author: Mr.Panda

README.md

@@ -22,6 +22,7 @@
 
 ### 版本
 开发阶段 </br>
+项目进度更新在 [项目看板](https://github.com/quasipaas/Quasipaa/projects/1)，可以随时跟踪.</br>
 
 
 ### 支持的编码器

lib/flv/src/audio.rs

@@ -0,0 +1,53 @@
+use bytes::{Bytes, BytesMut};
+use super::Metadata;
+
+/// 解析音频帧
+/// 
+/// 注意: 只支持AAC.
+/// 输入音频帧获得音频帧信息.
+pub fn decoder(data: BytesMut) -> Metadata {
+    let audio_object_type = data[2] >> 3;
+    let sampling_index = ((data[2] & 0x07) << 1) | (data[3] >> 7);
+    let sampling_frequence = match sampling_index {
+        0 => 96000, 
+        1 => 88200, 
+        2 => 64000, 
+        3 => 48000, 
+        4 => 44100, 
+        5 => 32000,
+        6 => 24000, 
+        7 => 22050, 
+        8 => 16000, 
+        9 => 12000, 
+        10 => 11025, 
+        11 => 8000, 
+        _ => 7350
+    };
+
+    let channel_config = (data[3] & 0x78) >> 3;
+    let mut extension_sampling = sampling_index;
+    if sampling_index >= 6 {
+        extension_sampling = sampling_index - 3;
+    }
+
+    let mut config = [0u8; 4];
+    config[0] = audio_object_type << 3;
+    config[0] |= (sampling_index & 0x0F) >> 1;
+    config[1] = (sampling_index & 0x0F) << 7;
+    config[1] |= (channel_config & 0x0F) << 3;
+    config[1] |= (extension_sampling & 0x0F) >> 1;
+    config[2] |= (extension_sampling & 0x01) << 7;
+    config[2] |= 2 << 2;
+
+    Metadata {
+        track_id: 2,
+        duration: 0,
+        timescale: 1000,
+        audio_sample_rate: sampling_frequence,
+        channel_count: channel_config,
+        codec: "mp4a.40.5".to_string(),
+        original_codec: "mp4a.40.5".to_string(),
+        config: Bytes::from(config.to_vec()),
+        ref_sample_duration: 1024 / sampling_frequence * 1000
+    }
+}

lib/flv/src/exp_golomb.rs

@@ -0,0 +1,98 @@
+use bytes::{BytesMut, BufMut, Buf};
+use std::cmp;
+
+pub struct ExpGolomb {
+    buffer: BytesMut,
+    index: usize,
+    total_bits: usize,
+    total_bytes: usize,
+    current_word: usize,
+    current_word_bits_left: usize
+}
+
+impl ExpGolomb {
+    pub fn new(data: &[u8]) -> Self {
+        let total_bytes = data.len();
+        Self {
+            index: 0,
+            total_bytes,
+            current_word: 0,
+            current_word_bits_left: 0,
+            total_bits: total_bytes * 8,
+            buffer: BytesMut::from(data),
+        }
+    }
+
+    #[rustfmt::skip]
+    fn fill_current_word(&mut self) {
+        let buffer_bytes_left = self.total_bytes - self.index;
+        let bytes_read = cmp::min(4, buffer_bytes_left);
+        let mut word = BytesMut::from(&self.buffer[self.index..self.index + bytes_read]);
+        self.current_word = word.get_u32() as usize;
+        self.current_word_bits_left = bytes_read * 8;
+        self.index = bytes_read;
+    }
+
+    #[rustfmt::skip]
+    fn skip_leading_zero(&mut self) -> usize {
+        let mut zero_count = 0;
+        for _ in zero_count..(self.current_word_bits_left - 1) {
+            if self.current_word & (0x80000000 >> zero_count) != 0 {
+                self.current_word <<= zero_count;
+                self.current_word_bits_left -= zero_count;
+                return zero_count;
+            }
+
+            zero_count += 1;
+        }
+
+        self.fill_current_word();
+        return zero_count + self.skip_leading_zero();
+    }
+
+    #[rustfmt::skip]
+    pub fn read_bits(&mut self, bits: usize) -> usize {
+        if bits <= self.current_word_bits_left {
+            let result = self.current_word >> (32 - bits);
+            self.current_word_bits_left -= bits;
+            self.current_word <<= bits;
+            return result;
+        }
+
+        let mut result = if self.current_word_bits_left > 0 { self.current_word } else { 0 };
+        result = result >> (32 - self.current_word_bits_left);
+        let bits_need_left = bits - self.current_word_bits_left;
+        self.fill_current_word();
+        let bits_read_next = cmp::min(bits_need_left, self.current_word_bits_left);
+        let result2 = self.current_word >> (32 - bits_read_next);
+        self.current_word_bits_left -= bits_read_next;
+        self.current_word <<= bits_read_next;
+        result = (result << bits_read_next) | result2;
+        result
+    }
+
+    #[rustfmt::skip]
+    pub fn read_bool(&mut self) -> bool {
+        self.read_bits(1) == 1
+    }
+
+    #[rustfmt::skip]
+    pub fn read_byte(&mut self) -> usize {
+        self.read_bits(8)
+    }
+
+    #[rustfmt::skip]
+    pub fn read_ueg(&mut self) -> usize {
+        let leading_zeros = self.skip_leading_zero();
+        self.read_bits(leading_zeros + 1) - 1
+    }
+
+    #[rustfmt::skip]
+    pub fn read_seg(&mut self) -> usize {
+        let value = self.read_ueg();
+        match value & 0x01 > 0 {
+            true => (value + 1) >> 1,
+            false => 0 - (value >> 1)
+        }
+    }
+}

lib/flv/src/lib.rs

@@ -1,3 +1,8 @@
+mod exp_golomb;
+mod audio;
+mod video;
+mod sps;
+
 use bytes::BytesMut;
 use bytes::BufMut; 
 use bytes::Bytes;
@@ -22,6 +27,20 @@ pub enum Tag {
     Video
 }
 
+/// 媒体信息
+#[derive(Debug)]
+pub struct Metadata {
+    pub track_id: u8,
+    pub timescale: u32,
+    pub duration: u32,
+    pub audio_sample_rate: u32,
+    pub channel_count: u8,
+    pub codec: String,
+    pub original_codec: String,
+    pub config: Bytes,
+    pub ref_sample_duration: u32
+}
+
 /// Create FLV frame
 ///
 /// Timestamp and TimestampExtended form the 

lib/flv/src/sps.rs

@@ -0,0 +1,46 @@
+use bytes::{BytesMut, BufMut, Buf};
+use super::exp_golomb::ExpGolomb;
+
+pub fn ebsp2rbsp(data: &[u8]) -> BytesMut {
+    let mut dst = BytesMut::new();
+    for i in 0..data.len() {
+        if i >= 2 {
+            let bit_1 = data[i] == 0x03;
+            let bit_2 = data[i - 1] == 0x00;
+            let bit_3 = data[i - 2] == 0x00;
+            if bit_1 && bit_2 && bit_3 {
+                continue;
+            }
+        }
+
+        dst.put_u8(data[i]);
+    }
+
+    dst
+}
+
+pub fn parse(mut data: BytesMut) {
+    let rbsp = ebsp2rbsp(&data);
+    let mut gb = ExpGolomb::new(&rbsp);
+
+    gb.read_byte();
+    let profile_idc = gb.read_byte();  // profile_idc
+    gb.read_byte();  // constraint_set_flags[5] + reserved_zero[3]
+    let level_idc = gb.read_byte();  // level_idc
+    gb.read_ueg();  // seq_parameter_set_id
+
+    let profile_string = get_profile_string(profile_idc);
+}
+
+pub fn get_profile_string(profile_idc: usize) -> &'static str {
+    match profile_idc {
+        66 => "Baseline",
+        77 => "Main",
+        88 => "Extended",
+        100 => "High",
+        110 => "High10",
+        122 => "High422",
+        244 => "High444",
+        _ => "Unknown"
+    }
+}

lib/flv/src/video.rs

@@ -0,0 +1,29 @@
+use bytes::{Bytes, BytesMut, Buf};
+use super::Metadata;
+
+/// 解析视频帧
+/// 
+/// 注意: 只支持H264
+pub fn decoder(mut data: BytesMut) {
+    let video_spec = data.get_u8();
+    let video_frame = (video_spec & 240) >> 4;
+    let codec_id = video_spec & 15;
+    let packet_type = data.get_u8();
+    let cts_unsigned = data.get_u32() & 0x00FFFFFF;
+    let cts = (cts_unsigned << 8) >> 8;
+    let version = data.get_u8();
+    let avc_profile = data.get_u8();
+    let profile_compatibility = data.get_u8();
+    let avclevel = data.get_u8();
+    let nalu_length_size = (data.get_u8() & 3) + 1;
+    let sps_count = data.get_u8() & 31;
+
+    for _ in 0..sps_count {
+        let len = data.get_u16();
+        if len == 0 {
+            continue;
+        }
+
+        
+    }
+}

lib/fmp4/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "fmp4"
+version = "0.1.0"
+authors = ["Mr.Panda <[email protected]>"]
+edition = "2018"
+
+[dependencies]
+bytes = "0.5.4"