Struct Video 

pub struct Video(/* private fields */);

Implementations

impl Video

pub unsafe fn wrap(ptr: *mut AVFrame) -> Self

pub unsafe fn alloc(&mut self, format: Pixel, width: u32, height: u32)

impl Video

pub fn empty() -> Self

Examples found in repository

examples/transcode-x264.rs (line 104)

    fn receive_and_process_decoded_frames(
        &mut self,
        octx: &mut format::context::Output,
        ost_time_base: Rational,
    ) {
        let mut frame = frame::Video::empty();
        while self.decoder.receive_frame(&mut frame).is_ok() {
            self.frame_count += 1;
            let timestamp = frame.timestamp();
            self.log_progress(f64::from(
                Rational(timestamp.unwrap_or(0) as i32, 1) * self.input_time_base,
            ));
            frame.set_pts(timestamp);
            frame.set_kind(picture::Type::None);
            self.send_frame_to_encoder(&frame);
            self.receive_and_process_encoded_packets(octx, ost_time_base);
        }
    }

examples/dump-frames.rs (line 38)

fn main() -> Result<(), ffmpeg::Error> {
    ffmpeg::init().unwrap();

    if let Ok(mut ictx) = input(&env::args().nth(1).expect("Cannot open file.")) {
        let input = ictx
            .streams()
            .best(Type::Video)
            .ok_or(ffmpeg::Error::StreamNotFound)?;
        let video_stream_index = input.index();

        let context_decoder = ffmpeg::codec::context::Context::from_parameters(input.parameters())?;
        let mut decoder = context_decoder.decoder().video()?;

        let mut scaler = Context::get(
            decoder.format(),
            decoder.width(),
            decoder.height(),
            Pixel::RGB24,
            decoder.width(),
            decoder.height(),
            Flags::BILINEAR,
        )?;

        let mut frame_index = 0;

        let mut receive_and_process_decoded_frames =
            |decoder: &mut ffmpeg::decoder::Video| -> Result<(), ffmpeg::Error> {
                let mut decoded = Video::empty();
                while decoder.receive_frame(&mut decoded).is_ok() {
                    let mut rgb_frame = Video::empty();
                    scaler.run(&decoded, &mut rgb_frame)?;
                    save_file(&rgb_frame, frame_index).unwrap();
                    frame_index += 1;
                }
                Ok(())
            };

        for (stream, packet) in ictx.packets() {
            if stream.index() == video_stream_index {
                decoder.send_packet(&packet)?;
                receive_and_process_decoded_frames(&mut decoder)?;
            }
        }
        decoder.send_eof()?;
        receive_and_process_decoded_frames(&mut decoder)?;
    }

    Ok(())
}

pub fn new(format: Pixel, width: u32, height: u32) -> Self

pub fn format(&self) -> Pixel

pub fn set_format(&mut self, value: Pixel)

pub fn kind(&self) -> Type

pub fn set_kind(&mut self, value: Type)

Examples found in repository

examples/transcode-x264.rs (line 112)

    fn receive_and_process_decoded_frames(
        &mut self,
        octx: &mut format::context::Output,
        ost_time_base: Rational,
    ) {
        let mut frame = frame::Video::empty();
        while self.decoder.receive_frame(&mut frame).is_ok() {
            self.frame_count += 1;
            let timestamp = frame.timestamp();
            self.log_progress(f64::from(
                Rational(timestamp.unwrap_or(0) as i32, 1) * self.input_time_base,
            ));
            frame.set_pts(timestamp);
            frame.set_kind(picture::Type::None);
            self.send_frame_to_encoder(&frame);
            self.receive_and_process_encoded_packets(octx, ost_time_base);
        }
    }

pub fn is_interlaced(&self) -> bool

pub fn is_top_first(&self) -> bool

pub fn has_palette_changed(&self) -> bool

pub fn width(&self) -> u32

Examples found in repository

examples/dump-frames.rs (line 63)

fn save_file(frame: &Video, index: usize) -> std::result::Result<(), std::io::Error> {
    let mut file = File::create(format!("frame{}.ppm", index))?;
    file.write_all(format!("P6\n{} {}\n255\n", frame.width(), frame.height()).as_bytes())?;
    file.write_all(frame.data(0))?;
    Ok(())
}

pub fn set_width(&mut self, value: u32)

pub fn height(&self) -> u32

Examples found in repository

examples/dump-frames.rs (line 63)

fn save_file(frame: &Video, index: usize) -> std::result::Result<(), std::io::Error> {
    let mut file = File::create(format!("frame{}.ppm", index))?;
    file.write_all(format!("P6\n{} {}\n255\n", frame.width(), frame.height()).as_bytes())?;
    file.write_all(frame.data(0))?;
    Ok(())
}

pub fn set_height(&mut self, value: u32)

pub fn color_space(&self) -> Space

pub fn set_color_space(&mut self, value: Space)

pub fn color_range(&self) -> Range

pub fn set_color_range(&mut self, value: Range)

pub fn color_primaries(&self) -> Primaries

pub fn set_color_primaries(&mut self, value: Primaries)

pub fn color_transfer_characteristic(&self) -> TransferCharacteristic

pub fn set_color_transfer_characteristic( &mut self, value: TransferCharacteristic, )

pub fn chroma_location(&self) -> Location

pub fn aspect_ratio(&self) -> Rational

pub fn coded_number(&self) -> usize

pub fn display_number(&self) -> usize

pub fn repeat(&self) -> f64

pub fn stride(&self, index: usize) -> usize

pub fn planes(&self) -> usize

pub fn plane_width(&self, index: usize) -> u32

pub fn plane_height(&self, index: usize) -> u32

pub fn plane<T: Component>(&self, index: usize) -> &[T]

pub fn plane_mut<T: Component>(&mut self, index: usize) -> &mut [T]

pub fn data(&self, index: usize) -> &[u8]

Examples found in repository

examples/dump-frames.rs (line 64)

fn save_file(frame: &Video, index: usize) -> std::result::Result<(), std::io::Error> {
    let mut file = File::create(format!("frame{}.ppm", index))?;
    file.write_all(format!("P6\n{} {}\n255\n", frame.width(), frame.height()).as_bytes())?;
    file.write_all(frame.data(0))?;
    Ok(())
}

pub fn data_mut(&mut self, index: usize) -> &mut [u8]

impl Video

pub fn scaler( &self, width: u32, height: u32, flags: Flags, ) -> Result<Context, Error>

pub fn converter(&self, format: Pixel) -> Result<Context, Error>

Methods from Deref<Target = Frame>

pub unsafe fn as_ptr(&self) -> *const AVFrame

pub unsafe fn as_mut_ptr(&mut self) -> *mut AVFrame

pub unsafe fn is_empty(&self) -> bool

pub fn is_key(&self) -> bool

pub fn is_corrupt(&self) -> bool

pub fn packet(&self) -> Packet

pub fn pts(&self) -> Option<i64>

pub fn set_pts(&mut self, value: Option<i64>)

Examples found in repository

examples/transcode-audio.rs (line 190)

    fn receive_and_process_decoded_frames(&mut self, octx: &mut format::context::Output) {
        let mut decoded = frame::Audio::empty();
        while self.decoder.receive_frame(&mut decoded).is_ok() {
            let timestamp = decoded.timestamp();
            decoded.set_pts(timestamp);
            self.add_frame_to_filter(&decoded);
            self.get_and_process_filtered_frames(octx);
        }
    }

examples/transcode-x264.rs (line 111)

    fn receive_and_process_decoded_frames(
        &mut self,
        octx: &mut format::context::Output,
        ost_time_base: Rational,
    ) {
        let mut frame = frame::Video::empty();
        while self.decoder.receive_frame(&mut frame).is_ok() {
            self.frame_count += 1;
            let timestamp = frame.timestamp();
            self.log_progress(f64::from(
                Rational(timestamp.unwrap_or(0) as i32, 1) * self.input_time_base,
            ));
            frame.set_pts(timestamp);
            frame.set_kind(picture::Type::None);
            self.send_frame_to_encoder(&frame);
            self.receive_and_process_encoded_packets(octx, ost_time_base);
        }
    }

pub fn timestamp(&self) -> Option<i64>

Examples found in repository

examples/transcode-audio.rs (line 189)

    fn receive_and_process_decoded_frames(&mut self, octx: &mut format::context::Output) {
        let mut decoded = frame::Audio::empty();
        while self.decoder.receive_frame(&mut decoded).is_ok() {
            let timestamp = decoded.timestamp();
            decoded.set_pts(timestamp);
            self.add_frame_to_filter(&decoded);
            self.get_and_process_filtered_frames(octx);
        }
    }

examples/transcode-x264.rs (line 107)

    fn receive_and_process_decoded_frames(
        &mut self,
        octx: &mut format::context::Output,
        ost_time_base: Rational,
    ) {
        let mut frame = frame::Video::empty();
        while self.decoder.receive_frame(&mut frame).is_ok() {
            self.frame_count += 1;
            let timestamp = frame.timestamp();
            self.log_progress(f64::from(
                Rational(timestamp.unwrap_or(0) as i32, 1) * self.input_time_base,
            ));
            frame.set_pts(timestamp);
            frame.set_kind(picture::Type::None);
            self.send_frame_to_encoder(&frame);
            self.receive_and_process_encoded_packets(octx, ost_time_base);
        }
    }

pub fn quality(&self) -> usize

pub fn flags(&self) -> Flags

pub fn metadata(&self) -> DictionaryRef<'_>

pub fn set_metadata(&mut self, value: Dictionary<'_>)

pub fn side_data(&self, kind: Type) -> Option<SideData<'_>>

pub fn new_side_data(&mut self, kind: Type, size: usize) -> Option<SideData<'_>>

pub fn remove_side_data(&mut self, kind: Type)

Trait Implementations

impl Clone for Video

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Deref for Video

type Target = Frame

The resulting type after dereferencing.

fn deref(&self) -> &Frame

Dereferences the value.

impl DerefMut for Video

fn deref_mut(&mut self) -> &mut Frame

Mutably dereferences the value.

impl From<Frame> for Video

fn from(frame: Frame) -> Self

Converts to this type from the input type.

impl PartialEq for Video

fn eq(&self, other: &Video) -> 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 Eq for Video

impl StructuralPartialEq for Video