Struct BitstreamReader 

pub struct BitstreamReader<'bs, 'data: 'bs, S: ReaderState> { /* private fields */ }

Reader for Bitstream.

Implementations

impl<S: ReaderState> BitstreamReader<'_, '_, S>

pub fn new<'bs, 'data>( bitstream: &'bs Bitstream<'data>, ) -> BitstreamReader<'bs, 'data, Beginning>

Construct BitstreamReader for Bitstream.

use oggopus_embedded::Bitstream;
let stream = Bitstream::new(include_bytes!("audio.opus"));

impl<'bs, 'data> BitstreamReader<'bs, 'data, Beginning>

pub fn read_header(self) -> Result<'data, EitherHeaderOrEnded<'bs, 'data>>

Read a header packet from Bitstream.

Also skips the comments packet and returs BitstreamReader that can read the following opus packets.

let reader = stream.reader();
let (reader, header) = reader.read_header().unwrap();
if let ChannelMapping::Family0 { channels } = header.channels {
    println!(
        "{} channels at {} Hz with pre skip of {}",
        channels, header.sample_rate, header.pre_skip
    );
}

impl<'bs, 'data> BitstreamReader<'bs, 'data, InStream>

pub fn next_packets<const BUFFER_SIZE: usize>( &self, ) -> Result<'data, EitherPacketsOrEnded<'bs, 'data, BUFFER_SIZE>>

Read next packets from Bitstream.

Returns also the next BitstreamReader to read further content.

let mut reader = match reader {
    Either::Continued(reader) => reader,
    _ => panic!("No more data"),
};
loop {
    let (new_reader, mut packets) = reader.next_packets::<1_024>().unwrap();
    while let Some(packet) = packets.next() {
        // Decode or whatever you need to do here
        println!("Got {} bytes of opus data", packet.data.len());
    }
    match new_reader {
        Either::Continued(new_reader) => {
            // Prepare for the next loop
            reader = new_reader;
        }
        Either::Ended(_reader) => {
            break; // You can also expect the next stream to start here
        }
    }
}

impl<'bs, 'data> BitstreamReader<'bs, 'data, EndOfStream>

pub fn has_more(&self) -> bool

Return whether there is more data to read.

pub fn next_reader(self) -> Option<BitstreamReader<'bs, 'data, Beginning>>

Get next reader for more data if there is any.

loop {
    let (new_reader, _packets) = reader.next_packets::<1_024>().unwrap();
    // ...
    match new_reader {
        Either::Continued(new_reader) => {
            reader = new_reader;
        }
        Either::Ended(old_reader) => {
            if let Some(new_reader) = old_reader.next_reader() {
                // Reinitialize decoding and continue looping
                let (new_reader, header) = new_reader.read_header().unwrap();
                if let Either::Continued(reader) = new_reader {
                }
            } else {
                break;
            }
        }
    }
}

Trait Implementations

impl<'bs, 'data: 'bs, S: Debug + ReaderState> Debug for BitstreamReader<'bs, 'data, S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'bs, 'data: 'bs, S: PartialEq + ReaderState> PartialEq for BitstreamReader<'bs, 'data, S>

fn eq(&self, other: &BitstreamReader<'bs, 'data, S>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'bs, 'data: 'bs, S: ReaderState> StructuralPartialEq for BitstreamReader<'bs, 'data, S>