From 56a7284e32946d0fadd9aa71fd14a3eddbdac6f2 Mon Sep 17 00:00:00 2001 From: Tangent 128 Date: Mon, 2 Apr 2018 18:37:47 -0400 Subject: [PATCH] Focus on Webm case specifically to get working code can retry generic EBML later --- src/bin/loop_server.rs | 2 +- src/chunk.rs | 20 ++++++++------------ src/ebml.rs | 13 ++----------- src/iterator.rs | 39 ++++++++++++++++----------------------- src/webm.rs | 11 +++++++++-- src/webm_stream.rs | 7 +++---- 6 files changed, 39 insertions(+), 53 deletions(-) diff --git a/src/bin/loop_server.rs b/src/bin/loop_server.rs index 74fadf2..6c0f85d 100644 --- a/src/bin/loop_server.rs +++ b/src/bin/loop_server.rs @@ -32,7 +32,7 @@ impl Service for WebmServer { let stream: BodyStream> = Box::new( repeat(()).take(10) .map(|()| - parse_webm(SRC_FILE).into_iter().chunk_webm() + parse_webm(SRC_FILE).chunk_webm() ).flatten() .fix_timecodes() .map_err(|err| match err { diff --git a/src/chunk.rs b/src/chunk.rs index af1b241..3c10b09 100644 --- a/src/chunk.rs +++ b/src/chunk.rs @@ -1,9 +1,7 @@ use futures::{Async, Stream}; use std::io::Cursor; -use std::marker::PhantomData; use std::mem; use std::sync::Arc; -use ebml::EbmlEventSource; use webm::*; #[derive(Clone, Debug)] @@ -89,13 +87,12 @@ pub enum ChunkingError { OtherError(E) } -pub struct WebmChunker<'a, S: EbmlEventSource<'a>> { +pub struct WebmChunker { source: S, - state: ChunkerState, - _marker: PhantomData<&'a [u8]> + state: ChunkerState } -impl<'a, S: EbmlEventSource<'a, Event = WebmElement<'a>>> Stream for WebmChunker<'a, S> +impl<'a, S: WebmEventSource> Stream for WebmChunker { type Item = Chunk; type Error = ChunkingError; @@ -212,16 +209,15 @@ impl<'a, S: EbmlEventSource<'a, Event = WebmElement<'a>>> Stream for WebmChunker } } -pub trait WebmStream<'a, T: EbmlEventSource<'a, Event = WebmElement<'a>>> { - fn chunk_webm(self) -> WebmChunker<'a, T>; +pub trait WebmStream { + fn chunk_webm(self) -> WebmChunker; } -impl<'a, T: EbmlEventSource<'a, Event = WebmElement<'a>>> WebmStream<'a, T> for T { - fn chunk_webm(self) -> WebmChunker<'a, T> { +impl<'a, T: WebmEventSource> WebmStream for T { + fn chunk_webm(self) -> WebmChunker { WebmChunker { source: self, - state: ChunkerState::BuildingHeader(Cursor::new(Vec::new())), - _marker: PhantomData + state: ChunkerState::BuildingHeader(Cursor::new(Vec::new())) } } } diff --git a/src/ebml.rs b/src/ebml.rs index fee53ab..2ef62fe 100644 --- a/src/ebml.rs +++ b/src/ebml.rs @@ -3,7 +3,6 @@ use futures::Async; use std::error::Error as ErrorTrait; use std::fmt::{Display, Formatter, Result as FmtResult}; use std::io::{Cursor, Error as IoError, ErrorKind, Result as IoResult, Write, Seek, SeekFrom}; -use std::marker::PhantomData; pub const EBML_HEAD_ID: u64 = 0x0A45DFA3; pub const DOC_TYPE_ID: u64 = 0x0282; @@ -216,9 +215,8 @@ pub fn encode_integer(tag: u64, value: u64, output: &mut T) -> IoResul } #[derive(Debug, PartialEq)] -pub struct Ebml { - pub source: Source, - _marker: PhantomData Element> +pub struct Ebml { + pub source: Source } pub trait FromEbml<'b>: Sized { @@ -251,13 +249,6 @@ pub trait FromEbml<'b>: Sized { } } } - - fn parse(source: T) -> Ebml { - Ebml { - source: source, - _marker: PhantomData - } - } } pub trait EbmlEventSource<'a> { diff --git a/src/iterator.rs b/src/iterator.rs index 4b3868e..0c1c477 100644 --- a/src/iterator.rs +++ b/src/iterator.rs @@ -1,32 +1,26 @@ -use std::marker::PhantomData; use futures::Async; use ebml::*; +use webm::*; -pub struct EbmlIterator<'b, T: FromEbml<'b>> { - slice: &'b[u8], - position: usize, - _marker: PhantomData T> +pub struct EbmlCursor { + source: T, + position: usize } -impl<'b, E: FromEbml<'b>> IntoIterator for Ebml<&'b[u8], E> { - type Item = E; - type IntoIter = EbmlIterator<'b, E>; - - fn into_iter(self) -> EbmlIterator<'b, E> - { - EbmlIterator { - slice: self.source, - position: 0, - _marker: PhantomData +impl EbmlCursor { + pub fn new(source: T) -> Self { + EbmlCursor { + source, + position: 0 } } } -impl<'b, T: FromEbml<'b>> Iterator for EbmlIterator<'b, T> { - type Item = T; +impl<'a> Iterator for EbmlCursor<&'a [u8]> { + type Item = WebmElement<'a>; - fn next(&mut self) -> Option { - match Self::Item::decode_element(&self.slice[self.position..]) { + fn next(&mut self) -> Option> { + match Self::Item::decode_element(&self.source[self.position..]) { Err(_) => None, Ok(None) => None, Ok(Some((element, element_size))) => { @@ -37,12 +31,11 @@ impl<'b, T: FromEbml<'b>> Iterator for EbmlIterator<'b, T> { } } -impl<'a, T: FromEbml<'a>> EbmlEventSource<'a> for EbmlIterator<'a, T> { - type Event = T; +impl<'b, T: AsRef<[u8]>> WebmEventSource for EbmlCursor { type Error = Error; - fn poll_event(&'a mut self) -> Result>, Error> { - match Self::Event::decode_element(&self.slice[self.position..]) { + fn poll_event<'a>(&'a mut self) -> Result>>, Error> { + match WebmElement::decode_element(&self.source.as_ref()[self.position..]) { Err(err) => Err(err), Ok(None) => Ok(Async::Ready(None)), Ok(Some((element, element_size))) => { diff --git a/src/webm.rs b/src/webm.rs index 39410ba..bce0a05 100644 --- a/src/webm.rs +++ b/src/webm.rs @@ -1,6 +1,8 @@ use std::io::{Cursor, Error as IoError, ErrorKind, Result as IoResult, Write, Seek}; use bytes::{BigEndian, BufMut, ByteOrder}; +use futures::Async; use ebml::*; +use iterator::EbmlCursor; const SEGMENT_ID: u64 = 0x08538067; const SEEK_HEAD_ID: u64 = 0x014D9B74; @@ -11,8 +13,8 @@ const CLUSTER_ID: u64 = 0x0F43B675; const TIMECODE_ID: u64 = 0x67; const SIMPLE_BLOCK_ID: u64 = 0x23; -pub fn parse_webm<'a, T: 'a>(source: T) -> Ebml> { - WebmElement::parse(source) +pub fn parse_webm>(source: T) -> EbmlCursor { + EbmlCursor::new(source) } #[derive(Debug, PartialEq, Copy, Clone)] @@ -125,6 +127,11 @@ pub fn encode_webm_element(element: &WebmElement, output: &mut } } +pub trait WebmEventSource { + type Error; + fn poll_event<'a>(&'a mut self) -> Result>>, Self::Error>; +} + #[cfg(test)] mod tests { use tests::TEST_FILE; diff --git a/src/webm_stream.rs b/src/webm_stream.rs index f23eb54..5f50fc0 100644 --- a/src/webm_stream.rs +++ b/src/webm_stream.rs @@ -71,12 +71,11 @@ impl, S: Stream> WebmStream { } } -impl<'a, I: AsRef<[u8]>, S: Stream> EbmlEventSource<'a> for WebmStream { - type Event = WebmElement<'a>; +impl, S: Stream> WebmEventSource for WebmStream { type Error = ParsingError; - fn poll_event(&'a mut self) -> Result>, Self::Error> { - return WebmStream::poll_event(&mut self); + fn poll_event<'a>(&'a mut self) -> Result>>, Self::Error> { + return WebmStream::poll_event(self); } }