Struct Packet 

pub struct Packet { /* private fields */ }

Implementations

impl Packet

pub fn new() -> Self

Examples found in repository

examples/generate_black_square_512x512.rs (line 65)

fn main() {
    let filename = "bk.png";
    let width = 512;
    let height = 512;

    let mut format_ctx =
        FormatContext::new("image2", filename, None).expect("Failed to create FormatContext");

    let mut codec = CodecContext::from_encoder_id(low_level::AVCodecID_AV_CODEC_ID_PNG)
        .expect("Failed to create CodecContext");

    let mut stream =
        Stream::new(&mut format_ctx, Some(&*codec)).expect("Failed to create a stream");

    codec
        .set_size(width, height)
        .set_framerate(1)
        .set_pixel_format(low_level::AVPixelFormat_AV_PIX_FMT_RGB24)
        .set_bitrate(400_000)
        .set_gop_size(1)
        .set_max_b_frames(1);

    if (format_ctx.get_output_format().flags & low_level::AVFMT_GLOBALHEADER as i32) != 0 {
        let flags = codec.get_flags() | low_level::AV_CODEC_FLAG_GLOBAL_HEADER as i32;

        codec.set_flags(flags);
    }

    match codec.open(None) {
        Err(err) => panic!("Error opening codec: {}", err),
        Ok(()) => {}
    };

    codec.fill_stream_parameters(&mut stream);

    match format_ctx.open(filename, AVIO_FLAG_WRITE as i32) {
        Err(err) => panic!("Error opening file! {err}"),
        Ok(()) => {}
    };

    format_ctx
        .write_header(None)
        .expect("Failed to write a header!");

    let mut frame = Frame::from_size_and_pixfmt(width, height, AVPixelFormat_AV_PIX_FMT_RGB24)
        .expect("Failed to make a frame!");

    let data = frame.data_plane_mut(0).expect("Failed to get plane!");

    for y in 0usize..height as usize {
        for x in 0usize..width as usize {
            let coord = y * (width as usize * 3usize) + (x * 3);

            data[coord + 0] = 0xff;
            data[coord + 1] = 0xff;
            data[coord + 2] = 0xff;
        }
    }

    codec.send_frame(&frame);

    let mut packet = Packet::new();

    codec.receive_packet(&mut packet);

    format_ctx.write_frame(&mut packet);

    packet.clear();

    format_ctx.write_trailer();

    println!("Hello, world!");
}

examples/decode_frame.rs (line 50)

fn main() {
    let url = if let Some(url) = std::env::args().skip(1).next() {
        url
    } else {
        eprintln!("No input file!");
        std::process::exit(1);
    };

    let mut format_context = FormatContext::open_input(&url).expect("Failed to open file!");

    format_context.find_stream_info();

    for i in format_context.streams() {
        println!("{i:#?}");
    }

    let video_stream = format_context
        .streams()
        .filter(|x| x.codec_parameters().is_video())
        .next()
        .expect("Failed to find a video stream");

    println!("CodecParams idx: {}", video_stream.index());
    println!(
        "CodecParams format: {}",
        video_stream.codec_parameters().format()
    );

    let mut codec = CodecContext::from_decoder_id(video_stream.codec_parameters().codec_id())
        .expect("Failed to create CodecContext");

    codec.fill_from_parameters(&video_stream.codec_parameters());

    codec.open(None).unwrap();

    println!("Pixel format: {}", codec.get_pixel_format());

    format_context.seek_msec(video_stream.index(), 4 * 60 * 1000);

    let mut packet = Packet::new();

    while format_context.read_frame(&mut packet) >= 0 {
        println!("{}", packet.stream_index());

        if packet.stream_index() == video_stream.index() {
            codec.send_packet(&packet);

            let mut frame = Frame::empty().expect("Failed to allocate a frame");

            while codec.receive_frame(&mut frame) >= 0 {
                println!("{}", frame.format());
                {
                    let (width, height) = video_stream.codec_parameters().size();
                    println!("{width} x {height}");

                    let mut new_frame =
                        Frame::from_size_and_pixfmt(width, height, AVPixelFormat_AV_PIX_FMT_RGB24)
                            .unwrap();

                    let sws = Sws::new(
                        width,
                        height,
                        video_stream.codec_parameters().format(),
                        width,
                        height,
                        AVPixelFormat_AV_PIX_FMT_RGB24,
                        SWS_BILINEAR as _,
                    );

                    println!("{:?} {:?}", frame.linesize(), new_frame.linesize());

                    sws.scale(&frame, &mut new_frame);

                    let mut file = std::fs::OpenOptions::new()
                        .create(true)
                        .truncate(true)
                        .write(true)
                        .open("data.bin")
                        .unwrap();

                    file.write(new_frame.data_plane(0).unwrap()).unwrap();
                }
            }

            break;
        }
    }

    println!("Exit!");
}

pub fn clear(&mut self)

Examples found in repository

examples/generate_black_square_512x512.rs (line 71)

fn main() {
    let filename = "bk.png";
    let width = 512;
    let height = 512;

    let mut format_ctx =
        FormatContext::new("image2", filename, None).expect("Failed to create FormatContext");

    let mut codec = CodecContext::from_encoder_id(low_level::AVCodecID_AV_CODEC_ID_PNG)
        .expect("Failed to create CodecContext");

    let mut stream =
        Stream::new(&mut format_ctx, Some(&*codec)).expect("Failed to create a stream");

    codec
        .set_size(width, height)
        .set_framerate(1)
        .set_pixel_format(low_level::AVPixelFormat_AV_PIX_FMT_RGB24)
        .set_bitrate(400_000)
        .set_gop_size(1)
        .set_max_b_frames(1);

    if (format_ctx.get_output_format().flags & low_level::AVFMT_GLOBALHEADER as i32) != 0 {
        let flags = codec.get_flags() | low_level::AV_CODEC_FLAG_GLOBAL_HEADER as i32;

        codec.set_flags(flags);
    }

    match codec.open(None) {
        Err(err) => panic!("Error opening codec: {}", err),
        Ok(()) => {}
    };

    codec.fill_stream_parameters(&mut stream);

    match format_ctx.open(filename, AVIO_FLAG_WRITE as i32) {
        Err(err) => panic!("Error opening file! {err}"),
        Ok(()) => {}
    };

    format_ctx
        .write_header(None)
        .expect("Failed to write a header!");

    let mut frame = Frame::from_size_and_pixfmt(width, height, AVPixelFormat_AV_PIX_FMT_RGB24)
        .expect("Failed to make a frame!");

    let data = frame.data_plane_mut(0).expect("Failed to get plane!");

    for y in 0usize..height as usize {
        for x in 0usize..width as usize {
            let coord = y * (width as usize * 3usize) + (x * 3);

            data[coord + 0] = 0xff;
            data[coord + 1] = 0xff;
            data[coord + 2] = 0xff;
        }
    }

    codec.send_frame(&frame);

    let mut packet = Packet::new();

    codec.receive_packet(&mut packet);

    format_ctx.write_frame(&mut packet);

    packet.clear();

    format_ctx.write_trailer();

    println!("Hello, world!");
}

pub fn stream_index(&self) -> i32

Examples found in repository

examples/decode_frame.rs (line 53)

fn main() {
    let url = if let Some(url) = std::env::args().skip(1).next() {
        url
    } else {
        eprintln!("No input file!");
        std::process::exit(1);
    };

    let mut format_context = FormatContext::open_input(&url).expect("Failed to open file!");

    format_context.find_stream_info();

    for i in format_context.streams() {
        println!("{i:#?}");
    }

    let video_stream = format_context
        .streams()
        .filter(|x| x.codec_parameters().is_video())
        .next()
        .expect("Failed to find a video stream");

    println!("CodecParams idx: {}", video_stream.index());
    println!(
        "CodecParams format: {}",
        video_stream.codec_parameters().format()
    );

    let mut codec = CodecContext::from_decoder_id(video_stream.codec_parameters().codec_id())
        .expect("Failed to create CodecContext");

    codec.fill_from_parameters(&video_stream.codec_parameters());

    codec.open(None).unwrap();

    println!("Pixel format: {}", codec.get_pixel_format());

    format_context.seek_msec(video_stream.index(), 4 * 60 * 1000);

    let mut packet = Packet::new();

    while format_context.read_frame(&mut packet) >= 0 {
        println!("{}", packet.stream_index());

        if packet.stream_index() == video_stream.index() {
            codec.send_packet(&packet);

            let mut frame = Frame::empty().expect("Failed to allocate a frame");

            while codec.receive_frame(&mut frame) >= 0 {
                println!("{}", frame.format());
                {
                    let (width, height) = video_stream.codec_parameters().size();
                    println!("{width} x {height}");

                    let mut new_frame =
                        Frame::from_size_and_pixfmt(width, height, AVPixelFormat_AV_PIX_FMT_RGB24)
                            .unwrap();

                    let sws = Sws::new(
                        width,
                        height,
                        video_stream.codec_parameters().format(),
                        width,
                        height,
                        AVPixelFormat_AV_PIX_FMT_RGB24,
                        SWS_BILINEAR as _,
                    );

                    println!("{:?} {:?}", frame.linesize(), new_frame.linesize());

                    sws.scale(&frame, &mut new_frame);

                    let mut file = std::fs::OpenOptions::new()
                        .create(true)
                        .truncate(true)
                        .write(true)
                        .open("data.bin")
                        .unwrap();

                    file.write(new_frame.data_plane(0).unwrap()).unwrap();
                }
            }

            break;
        }
    }

    println!("Exit!");
}

pub fn data(&self) -> &[u8]

pub fn duration(&self) -> i64

pub fn position(&self) -> i64

pub unsafe fn raw(&self) -> *const AVPacket

pub unsafe fn raw_mut(&mut self) -> *mut AVPacket

Trait Implementations

impl Default for Packet

fn default() -> Self

Returns the “default value” for a type.

impl Drop for Packet

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.