Function write_chunk

pub async fn write_chunk<'a, W: AsyncWrite>(
    writer: Pin<&'a mut W>,
    rtmp_context: &'a mut RtmpContext,
    chunk_id: u16,
    timestamp: Duration,
    message_type: MessageType,
    message_id: u32,
    data: &'a [u8],
) -> Result<()>

A wrapper for writing a chunk into streams. The RTMP needs to refer previous states for deciding sending chunk pattern. But to check them in every step is troublesome and also can make some bug. This reduces their risks.

Examples

use std::{
    io::Result as IOResult,
    pin::{
        Pin,
        pin
    },
    time::Duration
};
use sheave_core::{
    ByteBuffer,
    Encoder,
    handlers::{
        RtmpContext,
        VecStream
    },
    messages::{
        ChunkData,
        Connect,
        amf::v0::Object
    },
    readers::{
        read_basic_header,
        read_message_header,
        read_chunk_data
    },
    writers::write_chunk
};

#[tokio::main]
async fn main() -> IOResult<()> {
    let mut stream = pin!(VecStream::default());
    let mut rtmp_context = RtmpContext::default();
    let mut buffer = ByteBuffer::default();
    buffer.encode(&Connect::new(Object::default()));
    let expected: Vec<u8> = buffer.into();
    write_chunk(stream.as_mut(), &mut rtmp_context, Connect::CHANNEL.into(), Duration::default(), Connect::MESSAGE_TYPE, u32::default(), &expected).await?;

    let basic_header = read_basic_header(stream.as_mut()).await?;
    let message_header = read_message_header(stream.as_mut(), basic_header.get_message_format()).await?;
    let receiving_chunk_size = rtmp_context.get_receiving_chunk_size();
    let message_length = rtmp_context.get_last_sent_chunk(&basic_header.get_chunk_id()).unwrap().get_message_length();
    let actual = read_chunk_data(stream.as_mut(), receiving_chunk_size, message_length).await?;
    assert_eq!(expected, actual);

    Ok(())
}