Use a deque and process media packets as a substream

This commit is contained in:
QuantumEntangledAndy committed 2020-08-03 13:25:45 +07:00
1 parent 8ee375fda1
commit 963e4799c6
6 files changed
+295 -213

No files matched your search

+1 -3
View File
@@ -175,9 +175,7 @@ fn bc_modern_msg<'a, 'b, 'c>(
context.in_bin_mode.insert(header.msg_id);
let binary_data = BinaryData { data: payload };
binary = Some(binary_data);
binary = Some(payload);
buf = buf_after;
} else {
// Seriously, Nom, what even is this
+155
View File
@@ -0,0 +1,155 @@
use log::trace;
use std::cmp::min;
use std::convert::TryInto;
pub const CHUNK_SIZE: usize = 40000;
#[derive(Debug, PartialEq, Eq, Hash, Copy, Clone)]
pub enum MediaDataKind {
VideoDataIframe,
VideoDataPframe,
AudioDataAac,
AudioDataAdpcm,
InfoData,
Invalid,
Continue,
Unknown,
}
#[derive(Debug, PartialEq, Eq)]
pub struct MediaData {
pub data: Vec<u8>,
}
impl MediaData {
pub fn body(&self) -> &[u8] {
let lower_limit = self.header_size();
let upper_limit = self.data_size() + lower_limit;
let len = self.len();
if !self.complete() {
unreachable!(); // An incomplete packet should be discarded not read, panic if we try
}
trace!(
"Sending data from {} to {} of {}",
lower_limit,
upper_limit,
len
);
&self.data[lower_limit..upper_limit]
}
pub fn complete(&self) -> bool {
if self.len() < self.header_size() {
return false;
}
let full_data_len = self.len() - self.header_size();
full_data_len >= self.data_size() && full_data_len < self.data_size() + 8
}
pub fn expected_num_packet(&self) -> usize {
self.data_size() / CHUNK_SIZE + 1
}
pub fn header(&self) -> &[u8] {
let lower_limit = 0;
let upper_limit = self.header_size() + lower_limit;
&self.data[min(self.len(), lower_limit)..min(self.len(), upper_limit)]
}
pub fn header_size_from_raw(data: &[u8]) -> usize {
let kind = MediaData::kind_from_raw(data);
match kind {
MediaDataKind::VideoDataIframe => 32,
MediaDataKind::VideoDataPframe => 24,
MediaDataKind::AudioDataAac => 8,
MediaDataKind::AudioDataAdpcm => 16,
MediaDataKind::InfoData => 32,
MediaDataKind::Unknown | MediaDataKind::Invalid | MediaDataKind::Continue => 0,
}
}
pub fn header_size(&self) -> usize {
MediaData::header_size_from_raw(&self.data)
}
pub fn data_size_from_raw(data: &[u8]) -> usize {
let kind = MediaData::kind_from_raw(data);
match kind {
MediaDataKind::VideoDataIframe => MediaData::bytes_to_size(&data[8..12]),
MediaDataKind::VideoDataPframe => MediaData::bytes_to_size(&data[8..12]),
MediaDataKind::AudioDataAac => MediaData::bytes_to_size(&data[4..6]),
MediaDataKind::AudioDataAdpcm => MediaData::bytes_to_size(&data[4..6]),
MediaDataKind::InfoData => MediaData::bytes_to_size(&data[4..8]),
MediaDataKind::Unknown | MediaDataKind::Invalid | MediaDataKind::Continue => {
data.len()
}
}
}
pub fn data_size(&self) -> usize {
MediaData::data_size_from_raw(&self.data)
}
pub fn pad_size_from_raw(data: &[u8]) -> usize {
let data_size = MediaData::data_size_from_raw(data);
match data_size % 8 {
0 => 0,
n => 8 - n,
}
}
pub fn pad_size(&self) -> usize {
MediaData::data_size_from_raw(&self.data)
}
fn bytes_to_size(bytes: &[u8]) -> usize {
match bytes.len() {
// 8 Won't fit into usize on a 32-bit machine
4 => u32::from_le_bytes(bytes.try_into().expect("slice with incorrect length"))
.try_into()
.expect("u32 won't fit into usize"),
2 => u16::from_le_bytes(bytes.try_into().expect("slice with incorrect length"))
.try_into()
.expect("u16 won't fit into usize"),
1 => u8::from_le_bytes(bytes.try_into().expect("slice with incorrect length"))
.try_into()
.expect("u8 won't fit into usize"),
_ => unreachable!(),
}
}
pub fn kind_from_raw(data: &[u8]) -> MediaDataKind {
if data.len() < 4 {
return MediaDataKind::Invalid;
}
const MAGIC_VIDEO_INFO_V1: &[u8] = &[0x31, 0x30, 0x30, 0x31];
const MAGIC_VIDEO_INFO_V2: &[u8] = &[0x31, 0x30, 0x30, 0x32];
const MAGIC_AAC: &[u8] = &[0x30, 0x35, 0x77, 0x62];
const MAGIC_ADPCM: &[u8] = &[0x30, 0x31, 0x77, 0x62];
const MAGIC_IFRAME: &[u8] = &[0x30, 0x30, 0x64, 0x63];
const MAGIC_PFRAME: &[u8] = &[0x30, 0x31, 0x64, 0x63];
let magic = &data[..4];
match magic {
MAGIC_VIDEO_INFO_V1 | MAGIC_VIDEO_INFO_V2 => MediaDataKind::InfoData,
MAGIC_AAC => MediaDataKind::AudioDataAac,
MAGIC_ADPCM => MediaDataKind::AudioDataAdpcm,
MAGIC_IFRAME => MediaDataKind::VideoDataIframe,
MAGIC_PFRAME => MediaDataKind::VideoDataPframe,
_ if data.len() == CHUNK_SIZE => MediaDataKind::Continue,
_ => MediaDataKind::Unknown,
}
}
pub fn kind(&self) -> MediaDataKind {
MediaData::kind_from_raw(&self.data)
}
pub fn len(&self) -> usize {
self.data.len()
}
pub fn as_slice(&self) -> &[u8] {
self.data.as_slice()
}
}
+1
View File
@@ -11,6 +11,7 @@
//! "Extension" message.
pub mod model;
pub mod media_packet;
pub mod de;
pub mod ser;
+1 -132
View File
@@ -1,8 +1,5 @@
use super::xml::BcXml;
use log::trace;
use std::cmp::min;
use std::collections::HashSet;
use std::convert::TryInto;
pub(super) const MAGIC_HEADER: u32 = 0xabcdef0;
@@ -12,8 +9,6 @@ pub const MSG_ID_PING: u32 = 93;
pub const MSG_ID_GET_GENERAL: u32 = 104;
pub const MSG_ID_SET_GENERAL: u32 = 105;
pub const CHUNK_SIZE: usize = 40000;
pub const EMPTY_LEGACY_PASSWORD: &str =
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
@@ -29,136 +24,10 @@ pub enum BcBody {
ModernMsg(ModernMsg),
}
#[derive(Debug, PartialEq, Eq, Hash, Copy, Clone)]
pub enum BinaryDataKind {
VideoDataIframe,
VideoDataPframe,
AudioDataAac,
AudioDataAdpcm,
InfoData,
Invalid,
Continue,
Unknown,
}
#[derive(Debug, PartialEq, Eq)]
pub struct BinaryData {
pub data: Vec<u8>,
}
impl BinaryData {
pub fn body(&self) -> &[u8] {
let lower_limit = self.header_size();
let upper_limit = self.data_size() + lower_limit;
let len = self.len();
if !self.complete() {
unreachable!(); // An incomplete packet should be discarded not read, panic if we try
}
trace!(
"Sending data from {} to {} of {}",
lower_limit,
upper_limit,
len
);
&self.data[lower_limit..upper_limit]
}
pub fn complete(&self) -> bool {
if self.len() < self.header_size() {
return false;
}
let full_data_len = self.len() - self.header_size();
full_data_len >= self.data_size() && full_data_len < self.data_size() + 8
}
pub fn expected_num_packet(&self) -> usize {
self.data_size() / CHUNK_SIZE + 1
}
pub fn header(&self) -> &[u8] {
let lower_limit = 0;
let upper_limit = self.header_size() + lower_limit;
&self.data[min(self.len(), lower_limit)..min(self.len(), upper_limit)]
}
pub fn header_size(&self) -> usize {
match self.kind() {
BinaryDataKind::VideoDataIframe => 32,
BinaryDataKind::VideoDataPframe => 24,
BinaryDataKind::AudioDataAac => 8,
BinaryDataKind::AudioDataAdpcm => 16,
BinaryDataKind::InfoData => 32,
BinaryDataKind::Unknown | BinaryDataKind::Invalid | BinaryDataKind::Continue => 0,
}
}
pub fn data_size(&self) -> usize {
match self.kind() {
BinaryDataKind::VideoDataIframe => BinaryData::bytes_to_size(&self.data[8..12]),
BinaryDataKind::VideoDataPframe => BinaryData::bytes_to_size(&self.data[8..12]),
BinaryDataKind::AudioDataAac => BinaryData::bytes_to_size(&self.data[4..6]),
BinaryDataKind::AudioDataAdpcm => BinaryData::bytes_to_size(&self.data[4..6]),
BinaryDataKind::InfoData => BinaryData::bytes_to_size(&self.data[4..8]),
BinaryDataKind::Unknown | BinaryDataKind::Invalid | BinaryDataKind::Continue => {
self.data.len()
}
}
}
fn bytes_to_size(bytes: &[u8]) -> usize {
match bytes.len() {
// 8 Won't fit into usize on a 32-bit machine
4 => u32::from_le_bytes(bytes.try_into().expect("slice with incorrect length"))
.try_into()
.expect("u32 won't fit into usize"),
2 => u16::from_le_bytes(bytes.try_into().expect("slice with incorrect length"))
.try_into()
.expect("u16 won't fit into usize"),
1 => u8::from_le_bytes(bytes.try_into().expect("slice with incorrect length"))
.try_into()
.expect("u8 won't fit into usize"),
_ => unreachable!(),
}
}
pub fn kind(&self) -> BinaryDataKind {
const MAGIC_VIDEO_INFO: &[u8] = &[0x31, 0x30, 0x30, 0x31];
const MAGIC_AAC: &[u8] = &[0x30, 0x35, 0x77, 0x62];
const MAGIC_ADPCM: &[u8] = &[0x30, 0x31, 0x77, 0x62];
const MAGIC_IFRAME: &[u8] = &[0x30, 0x30, 0x64, 0x63];
const MAGIC_PFRAME: &[u8] = &[0x30, 0x31, 0x64, 0x63];
let magic = &self.data[..4];
match magic {
MAGIC_VIDEO_INFO => BinaryDataKind::InfoData,
MAGIC_AAC => BinaryDataKind::AudioDataAac,
MAGIC_ADPCM => BinaryDataKind::AudioDataAdpcm,
MAGIC_IFRAME => BinaryDataKind::VideoDataIframe,
MAGIC_PFRAME => BinaryDataKind::VideoDataPframe,
_ if self.len() == CHUNK_SIZE => BinaryDataKind::Continue,
_ => BinaryDataKind::Unknown,
}
}
pub fn len(&self) -> usize {
self.data.len()
}
pub fn as_slice(&self) -> &[u8] {
self.data.as_slice()
}
}
impl std::convert::AsRef<[u8]> for BinaryData {
fn as_ref(&self) -> &[u8] {
self.as_slice()
}
}
#[derive(Debug, Default, PartialEq, Eq)]
pub struct ModernMsg {
pub xml: Option<BcXml>,
pub binary: Option<BinaryData>,
pub binary: Option<Vec<u8>>,
}
#[derive(Debug, PartialEq, Eq)]
+11 -10
View File
@@ -1,6 +1,7 @@
use self::connection::BcConnection;
use crate::bc;
use crate::bc::{model::*, xml::*};
use crate::bc::media_packet::*;
use err_derive::Error;
use log::*;
use md5;
@@ -244,7 +245,7 @@ impl BcCamera {
.connection
.as_ref()
.expect("Must be connected to start video");
let sub_video = connection.subscribe(MSG_ID_VIDEO)?;
let mut sub_video = connection.subscribe(MSG_ID_VIDEO)?;
let start_video = Bc::new_from_xml(
BcMeta {
@@ -267,40 +268,40 @@ impl BcCamera {
sub_video.send(start_video)?;
loop {
let binary_data = sub_video.get_binary_data_of_kind(
let binary_data = sub_video.get_media_packet(
&vec![
BinaryDataKind::VideoDataIframe,
BinaryDataKind::VideoDataPframe,
MediaDataKind::VideoDataIframe,
MediaDataKind::VideoDataPframe,
],
RX_TIMEOUT,
)?;
// We now have a complete interesting packet. Send it to gst.
// Process the packet
match binary_data.kind() {
BinaryDataKind::VideoDataIframe | BinaryDataKind::VideoDataPframe => {
MediaDataKind::VideoDataIframe | MediaDataKind::VideoDataPframe => {
data_out.write_all(binary_data.body())?;
}
BinaryDataKind::AudioDataAac | BinaryDataKind::AudioDataAdpcm => {
MediaDataKind::AudioDataAac | MediaDataKind::AudioDataAdpcm => {
// We should not have a packet of this kind as we skip them until we get
// a packet of interest
unreachable!();
}
BinaryDataKind::InfoData => {
MediaDataKind::InfoData => {
// We should not have a packet of this kind as we skip them until we get
// a packet of interest
unreachable!();
}
BinaryDataKind::Unknown => {
MediaDataKind::Unknown => {
// We should not have a packet of this kind as we skip them until we get
// a packet of interest
unreachable!();
}
BinaryDataKind::Invalid => {
MediaDataKind::Invalid => {
// We should not have a packet of this kind as we skip them until we get
// a packet of interest
unreachable!();
}
BinaryDataKind::Continue => {
MediaDataKind::Continue => {
// We should not have a packet of this kind as it would be attached
// to a packet of interest
unreachable!();
+126 -68
View File
@@ -1,5 +1,6 @@
use crate::bc;
use crate::bc::model::*;
use crate::bc::media_packet::*;
use err_derive::Error;
use log::*;
use socket2::{Domain, Socket, Type};
@@ -10,6 +11,9 @@ use std::sync::mpsc::{channel, Receiver, Sender};
use std::sync::{Arc, Mutex};
use std::thread::JoinHandle;
use std::time::Duration;
use std::collections::VecDeque;
const INVALID_MEDIA_PACKETS: &[MediaDataKind] = &[MediaDataKind::Invalid, MediaDataKind::Continue, MediaDataKind::Unknown];
/// A shareable connection to a camera. Handles serialization of messages. To send/receive, call
/// .subscribe() with a message ID. You can use the BcSubscription to send or receive only
@@ -26,6 +30,7 @@ pub struct BcSubscription<'a> {
pub rx: Receiver<Bc>,
msg_id: u32,
conn: &'a BcConnection,
binary_buffer: VecDeque<u8>,
}
type Result<T> = std::result::Result<T, Error>;
@@ -78,6 +83,7 @@ impl BcConnection {
rx,
conn: self,
msg_id,
binary_buffer: VecDeque::new(),
})
}
@@ -143,76 +149,128 @@ impl<'a> BcSubscription<'a> {
Ok(())
}
pub fn get_binary_data_of_kind(
&self,
interested_kinds: &[BinaryDataKind],
rx_timeout: Duration,
) -> std::result::Result<BinaryData, Error> {
trace!("Finding binary message of interest...");
let mut binary_data: BinaryData;
// This loop is just for restarting (could have done with nesting too)
'outer: loop {
// Loop over the messages until we find one we want
loop {
let msg = self.rx.recv_timeout(rx_timeout)?;
if let BcBody::ModernMsg(ModernMsg {
binary: Some(binary),
..
}) = msg.body
{
match binary.kind() {
n if interested_kinds.contains(&n) => {
binary_data = binary;
break;
}
_ => {
trace!("Ignoring uninteresting binary data kind");
}
};
} else {
warn!("Ignoring weird binary message");
debug!("Contents: {:?}", msg);
}
fn fill_binary_buffer(&mut self, rx_timeout: Duration) -> Result<()> {
// Loop messages until we get binary
loop {
let msg = self.rx.recv_timeout(rx_timeout)?;
if let BcBody::ModernMsg(ModernMsg {
binary: Some(binary),
..
}) = msg.body
{
self.binary_buffer.extend(binary);
break;
}
trace!("Found binary message of interest...");
// If the binary date is not complete get more packets to complete it
while !binary_data.complete() {
let msg = self.rx.recv_timeout(rx_timeout)?;
if let BcBody::ModernMsg(ModernMsg {
binary: Some(binary),
..
}) = msg.body
{
match binary.kind() {
BinaryDataKind::Continue => {
// If its a continuation add it to our binary data
binary_data.data.extend(binary.data);
}
n if interested_kinds.contains(&n) => {
// If its another packet we are interested in
// Give up on current packet and try to complete
// This new one
// We are assuming that the camera has dropped that frame
trace!("Binary data was unfinished, found new interesting data");
binary_data = binary;
}
_ => {
// If we find something else then give up on the procees and restart
trace!("Binary data was unfinished, found uninteresting data");
continue 'outer;
}
}
} else {
warn!("Ignoring weird binary message");
debug!("Contents: {:?}", msg);
}
}
trace!("Have complete binary message.");
return Ok(binary_data);
}
Ok(())
}
fn advance_to_media_packet(&mut self, rx_timeout: Duration) -> Result<()> {
// In the event we get an unknown packet we advance by brute force
// reading of bytes to the next valid magic
trace!("Advancing to next know packet header");
while self.binary_buffer.len() < 4 {
self.fill_binary_buffer(rx_timeout)?;
}
// Check the kind, if its invalid use pop a byte and try again
let mut magic = BcSubscription::get_first_n_deque(&self.binary_buffer, 4);
while INVALID_MEDIA_PACKETS.contains(&MediaData::kind_from_raw(&magic)) {
self.binary_buffer.pop_front();
while self.binary_buffer.len() < 4 {
self.fill_binary_buffer(rx_timeout)?;
}
magic = BcSubscription::get_first_n_deque(&self.binary_buffer, 4);
}
Ok(())
}
fn get_first_n_deque<T: std::clone::Clone>(deque: &VecDeque<T>, n: usize) -> Vec<T> {
// NOTE: I want to use make_contiguous
// This will make this func unneeded as we can use
// make_contiguous then as_slices.0
// We won't need the clone in this case either.
// This is an experimental feature.
// It is able to be moved to stable though
// As can be seen from this PR
// https://github.com/rust-lang/rust/pull/74559
let slice0 = deque.as_slices().0;
let slice1 = deque.as_slices().1;
if slice0.len() >= n {
return slice0[0..n].iter().cloned().collect();
} else {
let remain = n - slice0.len();
return slice0.iter().chain(&slice1[0..remain]).cloned().collect();
}
}
fn next_media_packet(&mut self, rx_timeout: Duration) -> std::result::Result<MediaData, Error> {
// Get enough data for at least the magic
while self.binary_buffer.len() < 4 {
self.fill_binary_buffer(rx_timeout)?;
}
// Check the kind, if its invalid use advance to get a valid
// If not just grab the kind from the buffer
let mut magic = BcSubscription::get_first_n_deque(&self.binary_buffer, 4);
trace!("Magic 1: {:x?}", magic);
trace!("Kind: {:?}", MediaData::kind_from_raw(&magic));
if INVALID_MEDIA_PACKETS.contains(&MediaData::kind_from_raw(&magic)) {
// The if is because
// I presume this is expensive and only call when neccecary
self.advance_to_media_packet(rx_timeout)?;
magic = BcSubscription::get_first_n_deque(&self.binary_buffer, 4);
}
trace!("Magic 2: {:x?}", magic);
let kind = MediaData::kind_from_raw(&magic);
// Get enough for the full header
let header_size = MediaData::header_size_from_raw(&magic);
while self.binary_buffer.len() < header_size {
self.fill_binary_buffer(rx_timeout)?;
}
// Get enough for the full data + 8 byte buffer
let header = BcSubscription::get_first_n_deque(&self.binary_buffer, header_size);
trace!("Header: {:x?}", header);
let data_size = MediaData::data_size_from_raw(&header);
let pad_size = MediaData::pad_size_from_raw(&header);
let full_size = header_size + data_size + pad_size;
while self.binary_buffer.len() < full_size {
self.fill_binary_buffer(rx_timeout)?;
}
trace!("data_size: {}", data_size);
// Pop the full binary buffer
let binary = self.binary_buffer.drain(..full_size);
Ok(MediaData{
data: binary.collect()
})
}
pub fn get_media_packet(
&mut self,
interested_kinds: &[MediaDataKind],
rx_timeout: Duration,
) -> std::result::Result<MediaData, Error> {
trace!("Finding binary message of interest...");
let result_media_packet: MediaData;
// Loop over the messages until we find one we want
loop {
let media_packet = self.next_media_packet(rx_timeout)?;
match media_packet.kind() {
n if interested_kinds.contains(&n) => {
result_media_packet = media_packet;
break;
}
_ => {
trace!("Ignoring uninteresting binary data kind");
}
};
}
return Ok(result_media_packet);
}
}