Skip to main content

Decoder

libav_ng::avcodec::encoder_decoder

Struct Decoder 

Source 
pub struct Decoder { /* private fields */ }

Implementations§

Source§

impl Decoder

Source

pub fn receive_frame(&mut self, out: &mut Frame) -> i32

Examples found in repository?
examples/decode_frame.rs (line 60)
11fn main() {
12    let url = if let Some(url) = std::env::args().skip(1).next() {
13        url
14    } else {
15        eprintln!("No input file!");
16        std::process::exit(1);
17    };
18
19    let mut format_context = FormatContext::open_input(&url).expect("Failed to open file!");
20
21    format_context.find_stream_info();
22
23    for i in format_context.streams() {
24        println!("{i:#?}");
25    }
26
27    let video_stream = format_context
28        .streams()
29        .filter(|x| x.codec_parameters().is_video())
30        .next()
31        .expect("Failed to find a video stream");
32
33    println!("CodecParams idx: {}", video_stream.index());
34    println!(
35        "CodecParams format: {}",
36        video_stream.codec_parameters().format()
37    );
38
39    let mut codec = CodecContext::from_decoder_id(video_stream.codec_parameters().codec_id())
40        .expect("Failed to create CodecContext");
41
42    codec.fill_from_parameters(&video_stream.codec_parameters());
43
44    codec.open(None).unwrap();
45
46    println!("Pixel format: {}", codec.get_pixel_format());
47
48    format_context.seek_msec(video_stream.index(), 4 * 60 * 1000);
49
50    let mut packet = Packet::new();
51
52    while format_context.read_frame(&mut packet) >= 0 {
53        println!("{}", packet.stream_index());
54
55        if packet.stream_index() == video_stream.index() {
56            codec.send_packet(&packet);
57
58            let mut frame = Frame::empty().expect("Failed to allocate a frame");
59
60            while codec.receive_frame(&mut frame) >= 0 {
61                println!("{}", frame.format());
62                {
63                    let (width, height) = video_stream.codec_parameters().size();
64                    println!("{width} x {height}");
65
66                    let mut new_frame =
67                        Frame::from_size_and_pixfmt(width, height, AVPixelFormat_AV_PIX_FMT_RGB24)
68                            .unwrap();
69
70                    let sws = Sws::new(
71                        width,
72                        height,
73                        video_stream.codec_parameters().format(),
74                        width,
75                        height,
76                        AVPixelFormat_AV_PIX_FMT_RGB24,
77                        SWS_BILINEAR as _,
78                    );
79
80                    println!("{:?} {:?}", frame.linesize(), new_frame.linesize());
81
82                    sws.scale(&frame, &mut new_frame);
83
84                    let mut file = std::fs::OpenOptions::new()
85                        .create(true)
86                        .truncate(true)
87                        .write(true)
88                        .open("data.bin")
89                        .unwrap();
90
91                    file.write(new_frame.data_plane(0).unwrap()).unwrap();
92                }
93            }
94
95            break;
96        }
97    }
98
99    println!("Exit!");
100}

Methods from Deref<Target = CodecContext>§

Source

pub fn open(&mut self, options: Option<&mut Dictionary>) -> Result<(), i32>

Opens a codec

Examples found in repository?
examples/generate_black_square_512x512.rs (line 32)
4fn main() {
5    let filename = "bk.png";
6    let width = 512;
7    let height = 512;
8
9    let mut format_ctx =
10        FormatContext::new("image2", filename, None).expect("Failed to create FormatContext");
11
12    let mut codec = CodecContext::from_encoder_id(low_level::AVCodecID_AV_CODEC_ID_PNG)
13        .expect("Failed to create CodecContext");
14
15    let mut stream =
16        Stream::new(&mut format_ctx, Some(&*codec)).expect("Failed to create a stream");
17
18    codec
19        .set_size(width, height)
20        .set_framerate(1)
21        .set_pixel_format(low_level::AVPixelFormat_AV_PIX_FMT_RGB24)
22        .set_bitrate(400_000)
23        .set_gop_size(1)
24        .set_max_b_frames(1);
25
26    if (format_ctx.get_output_format().flags & low_level::AVFMT_GLOBALHEADER as i32) != 0 {
27        let flags = codec.get_flags() | low_level::AV_CODEC_FLAG_GLOBAL_HEADER as i32;
28
29        codec.set_flags(flags);
30    }
31
32    match codec.open(None) {
33        Err(err) => panic!("Error opening codec: {}", err),
34        Ok(()) => {}
35    };
36
37    codec.fill_stream_parameters(&mut stream);
38
39    match format_ctx.open(filename, AVIO_FLAG_WRITE as i32) {
40        Err(err) => panic!("Error opening file! {err}"),
41        Ok(()) => {}
42    };
43
44    format_ctx
45        .write_header(None)
46        .expect("Failed to write a header!");
47
48    let mut frame = Frame::from_size_and_pixfmt(width, height, AVPixelFormat_AV_PIX_FMT_RGB24)
49        .expect("Failed to make a frame!");
50
51    let data = frame.data_plane_mut(0).expect("Failed to get plane!");
52
53    for y in 0usize..height as usize {
54        for x in 0usize..width as usize {
55            let coord = y * (width as usize * 3usize) + (x * 3);
56
57            data[coord + 0] = 0xff;
58            data[coord + 1] = 0xff;
59            data[coord + 2] = 0xff;
60        }
61    }
62
63    codec.send_frame(&frame);
64
65    let mut packet = Packet::new();
66
67    codec.receive_packet(&mut packet);
68
69    format_ctx.write_frame(&mut packet);
70
71    packet.clear();
72
73    format_ctx.write_trailer();
74
75    println!("Hello, world!");
76}
More examples
Hide additional examples
examples/decode_frame.rs (line 44)
11fn main() {
12    let url = if let Some(url) = std::env::args().skip(1).next() {
13        url
14    } else {
15        eprintln!("No input file!");
16        std::process::exit(1);
17    };
18
19    let mut format_context = FormatContext::open_input(&url).expect("Failed to open file!");
20
21    format_context.find_stream_info();
22
23    for i in format_context.streams() {
24        println!("{i:#?}");
25    }
26
27    let video_stream = format_context
28        .streams()
29        .filter(|x| x.codec_parameters().is_video())
30        .next()
31        .expect("Failed to find a video stream");
32
33    println!("CodecParams idx: {}", video_stream.index());
34    println!(
35        "CodecParams format: {}",
36        video_stream.codec_parameters().format()
37    );
38
39    let mut codec = CodecContext::from_decoder_id(video_stream.codec_parameters().codec_id())
40        .expect("Failed to create CodecContext");
41
42    codec.fill_from_parameters(&video_stream.codec_parameters());
43
44    codec.open(None).unwrap();
45
46    println!("Pixel format: {}", codec.get_pixel_format());
47
48    format_context.seek_msec(video_stream.index(), 4 * 60 * 1000);
49
50    let mut packet = Packet::new();
51
52    while format_context.read_frame(&mut packet) >= 0 {
53        println!("{}", packet.stream_index());
54
55        if packet.stream_index() == video_stream.index() {
56            codec.send_packet(&packet);
57
58            let mut frame = Frame::empty().expect("Failed to allocate a frame");
59
60            while codec.receive_frame(&mut frame) >= 0 {
61                println!("{}", frame.format());
62                {
63                    let (width, height) = video_stream.codec_parameters().size();
64                    println!("{width} x {height}");
65
66                    let mut new_frame =
67                        Frame::from_size_and_pixfmt(width, height, AVPixelFormat_AV_PIX_FMT_RGB24)
68                            .unwrap();
69
70                    let sws = Sws::new(
71                        width,
72                        height,
73                        video_stream.codec_parameters().format(),
74                        width,
75                        height,
76                        AVPixelFormat_AV_PIX_FMT_RGB24,
77                        SWS_BILINEAR as _,
78                    );
79
80                    println!("{:?} {:?}", frame.linesize(), new_frame.linesize());
81
82                    sws.scale(&frame, &mut new_frame);
83
84                    let mut file = std::fs::OpenOptions::new()
85                        .create(true)
86                        .truncate(true)
87                        .write(true)
88                        .open("data.bin")
89                        .unwrap();
90
91                    file.write(new_frame.data_plane(0).unwrap()).unwrap();
92                }
93            }
94
95            break;
96        }
97    }
98
99    println!("Exit!");
100}
Source

pub fn set_size(&mut self, width: i32, height: i32) -> &mut Self

Set size of codec picture size

Examples found in repository?
examples/generate_black_square_512x512.rs (line 19)
4fn main() {
5    let filename = "bk.png";
6    let width = 512;
7    let height = 512;
8
9    let mut format_ctx =
10        FormatContext::new("image2", filename, None).expect("Failed to create FormatContext");
11
12    let mut codec = CodecContext::from_encoder_id(low_level::AVCodecID_AV_CODEC_ID_PNG)
13        .expect("Failed to create CodecContext");
14
15    let mut stream =
16        Stream::new(&mut format_ctx, Some(&*codec)).expect("Failed to create a stream");
17
18    codec
19        .set_size(width, height)
20        .set_framerate(1)
21        .set_pixel_format(low_level::AVPixelFormat_AV_PIX_FMT_RGB24)
22        .set_bitrate(400_000)
23        .set_gop_size(1)
24        .set_max_b_frames(1);
25
26    if (format_ctx.get_output_format().flags & low_level::AVFMT_GLOBALHEADER as i32) != 0 {
27        let flags = codec.get_flags() | low_level::AV_CODEC_FLAG_GLOBAL_HEADER as i32;
28
29        codec.set_flags(flags);
30    }
31
32    match codec.open(None) {
33        Err(err) => panic!("Error opening codec: {}", err),
34        Ok(()) => {}
35    };
36
37    codec.fill_stream_parameters(&mut stream);
38
39    match format_ctx.open(filename, AVIO_FLAG_WRITE as i32) {
40        Err(err) => panic!("Error opening file! {err}"),
41        Ok(()) => {}
42    };
43
44    format_ctx
45        .write_header(None)
46        .expect("Failed to write a header!");
47
48    let mut frame = Frame::from_size_and_pixfmt(width, height, AVPixelFormat_AV_PIX_FMT_RGB24)
49        .expect("Failed to make a frame!");
50
51    let data = frame.data_plane_mut(0).expect("Failed to get plane!");
52
53    for y in 0usize..height as usize {
54        for x in 0usize..width as usize {
55            let coord = y * (width as usize * 3usize) + (x * 3);
56
57            data[coord + 0] = 0xff;
58            data[coord + 1] = 0xff;
59            data[coord + 2] = 0xff;
60        }
61    }
62
63    codec.send_frame(&frame);
64
65    let mut packet = Packet::new();
66
67    codec.receive_packet(&mut packet);
68
69    format_ctx.write_frame(&mut packet);
70
71    packet.clear();
72
73    format_ctx.write_trailer();
74
75    println!("Hello, world!");
76}
Source

pub fn get_size(&self) -> (i32, i32)

Get size of codec picture size

Source

pub fn set_bitrate(&mut self, bitrate: i64) -> &mut CodecContext

Set bitrate

Examples found in repository?
examples/generate_black_square_512x512.rs (line 22)
4fn main() {
5    let filename = "bk.png";
6    let width = 512;
7    let height = 512;
8
9    let mut format_ctx =
10        FormatContext::new("image2", filename, None).expect("Failed to create FormatContext");
11
12    let mut codec = CodecContext::from_encoder_id(low_level::AVCodecID_AV_CODEC_ID_PNG)
13        .expect("Failed to create CodecContext");
14
15    let mut stream =
16        Stream::new(&mut format_ctx, Some(&*codec)).expect("Failed to create a stream");
17
18    codec
19        .set_size(width, height)
20        .set_framerate(1)
21        .set_pixel_format(low_level::AVPixelFormat_AV_PIX_FMT_RGB24)
22        .set_bitrate(400_000)
23        .set_gop_size(1)
24        .set_max_b_frames(1);
25
26    if (format_ctx.get_output_format().flags & low_level::AVFMT_GLOBALHEADER as i32) != 0 {
27        let flags = codec.get_flags() | low_level::AV_CODEC_FLAG_GLOBAL_HEADER as i32;
28
29        codec.set_flags(flags);
30    }
31
32    match codec.open(None) {
33        Err(err) => panic!("Error opening codec: {}", err),
34        Ok(()) => {}
35    };
36
37    codec.fill_stream_parameters(&mut stream);
38
39    match format_ctx.open(filename, AVIO_FLAG_WRITE as i32) {
40        Err(err) => panic!("Error opening file! {err}"),
41        Ok(()) => {}
42    };
43
44    format_ctx
45        .write_header(None)
46        .expect("Failed to write a header!");
47
48    let mut frame = Frame::from_size_and_pixfmt(width, height, AVPixelFormat_AV_PIX_FMT_RGB24)
49        .expect("Failed to make a frame!");
50
51    let data = frame.data_plane_mut(0).expect("Failed to get plane!");
52
53    for y in 0usize..height as usize {
54        for x in 0usize..width as usize {
55            let coord = y * (width as usize * 3usize) + (x * 3);
56
57            data[coord + 0] = 0xff;
58            data[coord + 1] = 0xff;
59            data[coord + 2] = 0xff;
60        }
61    }
62
63    codec.send_frame(&frame);
64
65    let mut packet = Packet::new();
66
67    codec.receive_packet(&mut packet);
68
69    format_ctx.write_frame(&mut packet);
70
71    packet.clear();
72
73    format_ctx.write_trailer();
74
75    println!("Hello, world!");
76}
Source

pub fn get_bitrate(&self) -> i64

Get bitrate

Source

pub fn set_framerate(&mut self, fps: i32) -> &mut CodecContext

Set framerate (this also sets time_base but in inverse order)

Examples found in repository?
examples/generate_black_square_512x512.rs (line 20)
4fn main() {
5    let filename = "bk.png";
6    let width = 512;
7    let height = 512;
8
9    let mut format_ctx =
10        FormatContext::new("image2", filename, None).expect("Failed to create FormatContext");
11
12    let mut codec = CodecContext::from_encoder_id(low_level::AVCodecID_AV_CODEC_ID_PNG)
13        .expect("Failed to create CodecContext");
14
15    let mut stream =
16        Stream::new(&mut format_ctx, Some(&*codec)).expect("Failed to create a stream");
17
18    codec
19        .set_size(width, height)
20        .set_framerate(1)
21        .set_pixel_format(low_level::AVPixelFormat_AV_PIX_FMT_RGB24)
22        .set_bitrate(400_000)
23        .set_gop_size(1)
24        .set_max_b_frames(1);
25
26    if (format_ctx.get_output_format().flags & low_level::AVFMT_GLOBALHEADER as i32) != 0 {
27        let flags = codec.get_flags() | low_level::AV_CODEC_FLAG_GLOBAL_HEADER as i32;
28
29        codec.set_flags(flags);
30    }
31
32    match codec.open(None) {
33        Err(err) => panic!("Error opening codec: {}", err),
34        Ok(()) => {}
35    };
36
37    codec.fill_stream_parameters(&mut stream);
38
39    match format_ctx.open(filename, AVIO_FLAG_WRITE as i32) {
40        Err(err) => panic!("Error opening file! {err}"),
41        Ok(()) => {}
42    };
43
44    format_ctx
45        .write_header(None)
46        .expect("Failed to write a header!");
47
48    let mut frame = Frame::from_size_and_pixfmt(width, height, AVPixelFormat_AV_PIX_FMT_RGB24)
49        .expect("Failed to make a frame!");
50
51    let data = frame.data_plane_mut(0).expect("Failed to get plane!");
52
53    for y in 0usize..height as usize {
54        for x in 0usize..width as usize {
55            let coord = y * (width as usize * 3usize) + (x * 3);
56
57            data[coord + 0] = 0xff;
58            data[coord + 1] = 0xff;
59            data[coord + 2] = 0xff;
60        }
61    }
62
63    codec.send_frame(&frame);
64
65    let mut packet = Packet::new();
66
67    codec.receive_packet(&mut packet);
68
69    format_ctx.write_frame(&mut packet);
70
71    packet.clear();
72
73    format_ctx.write_trailer();
74
75    println!("Hello, world!");
76}
Source

pub fn get_framerate(&self) -> AVRational

Get framerate

Source

pub fn get_time_base(&self) -> AVRational

Get time base

Source

pub fn set_pixel_format(&mut self, fmt: AVPixelFormat) -> &mut CodecContext

Set pixel format

Examples found in repository?
examples/generate_black_square_512x512.rs (line 21)
4fn main() {
5    let filename = "bk.png";
6    let width = 512;
7    let height = 512;
8
9    let mut format_ctx =
10        FormatContext::new("image2", filename, None).expect("Failed to create FormatContext");
11
12    let mut codec = CodecContext::from_encoder_id(low_level::AVCodecID_AV_CODEC_ID_PNG)
13        .expect("Failed to create CodecContext");
14
15    let mut stream =
16        Stream::new(&mut format_ctx, Some(&*codec)).expect("Failed to create a stream");
17
18    codec
19        .set_size(width, height)
20        .set_framerate(1)
21        .set_pixel_format(low_level::AVPixelFormat_AV_PIX_FMT_RGB24)
22        .set_bitrate(400_000)
23        .set_gop_size(1)
24        .set_max_b_frames(1);
25
26    if (format_ctx.get_output_format().flags & low_level::AVFMT_GLOBALHEADER as i32) != 0 {
27        let flags = codec.get_flags() | low_level::AV_CODEC_FLAG_GLOBAL_HEADER as i32;
28
29        codec.set_flags(flags);
30    }
31
32    match codec.open(None) {
33        Err(err) => panic!("Error opening codec: {}", err),
34        Ok(()) => {}
35    };
36
37    codec.fill_stream_parameters(&mut stream);
38
39    match format_ctx.open(filename, AVIO_FLAG_WRITE as i32) {
40        Err(err) => panic!("Error opening file! {err}"),
41        Ok(()) => {}
42    };
43
44    format_ctx
45        .write_header(None)
46        .expect("Failed to write a header!");
47
48    let mut frame = Frame::from_size_and_pixfmt(width, height, AVPixelFormat_AV_PIX_FMT_RGB24)
49        .expect("Failed to make a frame!");
50
51    let data = frame.data_plane_mut(0).expect("Failed to get plane!");
52
53    for y in 0usize..height as usize {
54        for x in 0usize..width as usize {
55            let coord = y * (width as usize * 3usize) + (x * 3);
56
57            data[coord + 0] = 0xff;
58            data[coord + 1] = 0xff;
59            data[coord + 2] = 0xff;
60        }
61    }
62
63    codec.send_frame(&frame);
64
65    let mut packet = Packet::new();
66
67    codec.receive_packet(&mut packet);
68
69    format_ctx.write_frame(&mut packet);
70
71    packet.clear();
72
73    format_ctx.write_trailer();
74
75    println!("Hello, world!");
76}
Source

pub fn get_pixel_format(&self) -> AVPixelFormat

Get pixel format

Examples found in repository?
examples/decode_frame.rs (line 46)
11fn main() {
12    let url = if let Some(url) = std::env::args().skip(1).next() {
13        url
14    } else {
15        eprintln!("No input file!");
16        std::process::exit(1);
17    };
18
19    let mut format_context = FormatContext::open_input(&url).expect("Failed to open file!");
20
21    format_context.find_stream_info();
22
23    for i in format_context.streams() {
24        println!("{i:#?}");
25    }
26
27    let video_stream = format_context
28        .streams()
29        .filter(|x| x.codec_parameters().is_video())
30        .next()
31        .expect("Failed to find a video stream");
32
33    println!("CodecParams idx: {}", video_stream.index());
34    println!(
35        "CodecParams format: {}",
36        video_stream.codec_parameters().format()
37    );
38
39    let mut codec = CodecContext::from_decoder_id(video_stream.codec_parameters().codec_id())
40        .expect("Failed to create CodecContext");
41
42    codec.fill_from_parameters(&video_stream.codec_parameters());
43
44    codec.open(None).unwrap();
45
46    println!("Pixel format: {}", codec.get_pixel_format());
47
48    format_context.seek_msec(video_stream.index(), 4 * 60 * 1000);
49
50    let mut packet = Packet::new();
51
52    while format_context.read_frame(&mut packet) >= 0 {
53        println!("{}", packet.stream_index());
54
55        if packet.stream_index() == video_stream.index() {
56            codec.send_packet(&packet);
57
58            let mut frame = Frame::empty().expect("Failed to allocate a frame");
59
60            while codec.receive_frame(&mut frame) >= 0 {
61                println!("{}", frame.format());
62                {
63                    let (width, height) = video_stream.codec_parameters().size();
64                    println!("{width} x {height}");
65
66                    let mut new_frame =
67                        Frame::from_size_and_pixfmt(width, height, AVPixelFormat_AV_PIX_FMT_RGB24)
68                            .unwrap();
69
70                    let sws = Sws::new(
71                        width,
72                        height,
73                        video_stream.codec_parameters().format(),
74                        width,
75                        height,
76                        AVPixelFormat_AV_PIX_FMT_RGB24,
77                        SWS_BILINEAR as _,
78                    );
79
80                    println!("{:?} {:?}", frame.linesize(), new_frame.linesize());
81
82                    sws.scale(&frame, &mut new_frame);
83
84                    let mut file = std::fs::OpenOptions::new()
85                        .create(true)
86                        .truncate(true)
87                        .write(true)
88                        .open("data.bin")
89                        .unwrap();
90
91                    file.write(new_frame.data_plane(0).unwrap()).unwrap();
92                }
93            }
94
95            break;
96        }
97    }
98
99    println!("Exit!");
100}
Source

pub fn set_gop_size(&mut self, gop_size: i32) -> &mut CodecContext

Examples found in repository?
examples/generate_black_square_512x512.rs (line 23)
4fn main() {
5    let filename = "bk.png";
6    let width = 512;
7    let height = 512;
8
9    let mut format_ctx =
10        FormatContext::new("image2", filename, None).expect("Failed to create FormatContext");
11
12    let mut codec = CodecContext::from_encoder_id(low_level::AVCodecID_AV_CODEC_ID_PNG)
13        .expect("Failed to create CodecContext");
14
15    let mut stream =
16        Stream::new(&mut format_ctx, Some(&*codec)).expect("Failed to create a stream");
17
18    codec
19        .set_size(width, height)
20        .set_framerate(1)
21        .set_pixel_format(low_level::AVPixelFormat_AV_PIX_FMT_RGB24)
22        .set_bitrate(400_000)
23        .set_gop_size(1)
24        .set_max_b_frames(1);
25
26    if (format_ctx.get_output_format().flags & low_level::AVFMT_GLOBALHEADER as i32) != 0 {
27        let flags = codec.get_flags() | low_level::AV_CODEC_FLAG_GLOBAL_HEADER as i32;
28
29        codec.set_flags(flags);
30    }
31
32    match codec.open(None) {
33        Err(err) => panic!("Error opening codec: {}", err),
34        Ok(()) => {}
35    };
36
37    codec.fill_stream_parameters(&mut stream);
38
39    match format_ctx.open(filename, AVIO_FLAG_WRITE as i32) {
40        Err(err) => panic!("Error opening file! {err}"),
41        Ok(()) => {}
42    };
43
44    format_ctx
45        .write_header(None)
46        .expect("Failed to write a header!");
47
48    let mut frame = Frame::from_size_and_pixfmt(width, height, AVPixelFormat_AV_PIX_FMT_RGB24)
49        .expect("Failed to make a frame!");
50
51    let data = frame.data_plane_mut(0).expect("Failed to get plane!");
52
53    for y in 0usize..height as usize {
54        for x in 0usize..width as usize {
55            let coord = y * (width as usize * 3usize) + (x * 3);
56
57            data[coord + 0] = 0xff;
58            data[coord + 1] = 0xff;
59            data[coord + 2] = 0xff;
60        }
61    }
62
63    codec.send_frame(&frame);
64
65    let mut packet = Packet::new();
66
67    codec.receive_packet(&mut packet);
68
69    format_ctx.write_frame(&mut packet);
70
71    packet.clear();
72
73    format_ctx.write_trailer();
74
75    println!("Hello, world!");
76}
Source

pub fn get_gop_size(&self) -> i32

Source

pub fn set_max_b_frames(&mut self, max_b_frames: i32) -> &mut CodecContext

Examples found in repository?
examples/generate_black_square_512x512.rs (line 24)
4fn main() {
5    let filename = "bk.png";
6    let width = 512;
7    let height = 512;
8
9    let mut format_ctx =
10        FormatContext::new("image2", filename, None).expect("Failed to create FormatContext");
11
12    let mut codec = CodecContext::from_encoder_id(low_level::AVCodecID_AV_CODEC_ID_PNG)
13        .expect("Failed to create CodecContext");
14
15    let mut stream =
16        Stream::new(&mut format_ctx, Some(&*codec)).expect("Failed to create a stream");
17
18    codec
19        .set_size(width, height)
20        .set_framerate(1)
21        .set_pixel_format(low_level::AVPixelFormat_AV_PIX_FMT_RGB24)
22        .set_bitrate(400_000)
23        .set_gop_size(1)
24        .set_max_b_frames(1);
25
26    if (format_ctx.get_output_format().flags & low_level::AVFMT_GLOBALHEADER as i32) != 0 {
27        let flags = codec.get_flags() | low_level::AV_CODEC_FLAG_GLOBAL_HEADER as i32;
28
29        codec.set_flags(flags);
30    }
31
32    match codec.open(None) {
33        Err(err) => panic!("Error opening codec: {}", err),
34        Ok(()) => {}
35    };
36
37    codec.fill_stream_parameters(&mut stream);
38
39    match format_ctx.open(filename, AVIO_FLAG_WRITE as i32) {
40        Err(err) => panic!("Error opening file! {err}"),
41        Ok(()) => {}
42    };
43
44    format_ctx
45        .write_header(None)
46        .expect("Failed to write a header!");
47
48    let mut frame = Frame::from_size_and_pixfmt(width, height, AVPixelFormat_AV_PIX_FMT_RGB24)
49        .expect("Failed to make a frame!");
50
51    let data = frame.data_plane_mut(0).expect("Failed to get plane!");
52
53    for y in 0usize..height as usize {
54        for x in 0usize..width as usize {
55            let coord = y * (width as usize * 3usize) + (x * 3);
56
57            data[coord + 0] = 0xff;
58            data[coord + 1] = 0xff;
59            data[coord + 2] = 0xff;
60        }
61    }
62
63    codec.send_frame(&frame);
64
65    let mut packet = Packet::new();
66
67    codec.receive_packet(&mut packet);
68
69    format_ctx.write_frame(&mut packet);
70
71    packet.clear();
72
73    format_ctx.write_trailer();
74
75    println!("Hello, world!");
76}
Source

pub fn fill_parameters(&self, params: &mut CodecParameters)

Fills parameters from codec into params

Source

pub fn fill_from_parameters(&self, params: &CodecParameters)

Fills codec parameters from params

Examples found in repository?
examples/decode_frame.rs (line 42)
11fn main() {
12    let url = if let Some(url) = std::env::args().skip(1).next() {
13        url
14    } else {
15        eprintln!("No input file!");
16        std::process::exit(1);
17    };
18
19    let mut format_context = FormatContext::open_input(&url).expect("Failed to open file!");
20
21    format_context.find_stream_info();
22
23    for i in format_context.streams() {
24        println!("{i:#?}");
25    }
26
27    let video_stream = format_context
28        .streams()
29        .filter(|x| x.codec_parameters().is_video())
30        .next()
31        .expect("Failed to find a video stream");
32
33    println!("CodecParams idx: {}", video_stream.index());
34    println!(
35        "CodecParams format: {}",
36        video_stream.codec_parameters().format()
37    );
38
39    let mut codec = CodecContext::from_decoder_id(video_stream.codec_parameters().codec_id())
40        .expect("Failed to create CodecContext");
41
42    codec.fill_from_parameters(&video_stream.codec_parameters());
43
44    codec.open(None).unwrap();
45
46    println!("Pixel format: {}", codec.get_pixel_format());
47
48    format_context.seek_msec(video_stream.index(), 4 * 60 * 1000);
49
50    let mut packet = Packet::new();
51
52    while format_context.read_frame(&mut packet) >= 0 {
53        println!("{}", packet.stream_index());
54
55        if packet.stream_index() == video_stream.index() {
56            codec.send_packet(&packet);
57
58            let mut frame = Frame::empty().expect("Failed to allocate a frame");
59
60            while codec.receive_frame(&mut frame) >= 0 {
61                println!("{}", frame.format());
62                {
63                    let (width, height) = video_stream.codec_parameters().size();
64                    println!("{width} x {height}");
65
66                    let mut new_frame =
67                        Frame::from_size_and_pixfmt(width, height, AVPixelFormat_AV_PIX_FMT_RGB24)
68                            .unwrap();
69
70                    let sws = Sws::new(
71                        width,
72                        height,
73                        video_stream.codec_parameters().format(),
74                        width,
75                        height,
76                        AVPixelFormat_AV_PIX_FMT_RGB24,
77                        SWS_BILINEAR as _,
78                    );
79
80                    println!("{:?} {:?}", frame.linesize(), new_frame.linesize());
81
82                    sws.scale(&frame, &mut new_frame);
83
84                    let mut file = std::fs::OpenOptions::new()
85                        .create(true)
86                        .truncate(true)
87                        .write(true)
88                        .open("data.bin")
89                        .unwrap();
90
91                    file.write(new_frame.data_plane(0).unwrap()).unwrap();
92                }
93            }
94
95            break;
96        }
97    }
98
99    println!("Exit!");
100}
Source

pub fn fill_stream_parameters(&self, stream: &Stream)

Examples found in repository?
examples/generate_black_square_512x512.rs (line 37)
4fn main() {
5    let filename = "bk.png";
6    let width = 512;
7    let height = 512;
8
9    let mut format_ctx =
10        FormatContext::new("image2", filename, None).expect("Failed to create FormatContext");
11
12    let mut codec = CodecContext::from_encoder_id(low_level::AVCodecID_AV_CODEC_ID_PNG)
13        .expect("Failed to create CodecContext");
14
15    let mut stream =
16        Stream::new(&mut format_ctx, Some(&*codec)).expect("Failed to create a stream");
17
18    codec
19        .set_size(width, height)
20        .set_framerate(1)
21        .set_pixel_format(low_level::AVPixelFormat_AV_PIX_FMT_RGB24)
22        .set_bitrate(400_000)
23        .set_gop_size(1)
24        .set_max_b_frames(1);
25
26    if (format_ctx.get_output_format().flags & low_level::AVFMT_GLOBALHEADER as i32) != 0 {
27        let flags = codec.get_flags() | low_level::AV_CODEC_FLAG_GLOBAL_HEADER as i32;
28
29        codec.set_flags(flags);
30    }
31
32    match codec.open(None) {
33        Err(err) => panic!("Error opening codec: {}", err),
34        Ok(()) => {}
35    };
36
37    codec.fill_stream_parameters(&mut stream);
38
39    match format_ctx.open(filename, AVIO_FLAG_WRITE as i32) {
40        Err(err) => panic!("Error opening file! {err}"),
41        Ok(()) => {}
42    };
43
44    format_ctx
45        .write_header(None)
46        .expect("Failed to write a header!");
47
48    let mut frame = Frame::from_size_and_pixfmt(width, height, AVPixelFormat_AV_PIX_FMT_RGB24)
49        .expect("Failed to make a frame!");
50
51    let data = frame.data_plane_mut(0).expect("Failed to get plane!");
52
53    for y in 0usize..height as usize {
54        for x in 0usize..width as usize {
55            let coord = y * (width as usize * 3usize) + (x * 3);
56
57            data[coord + 0] = 0xff;
58            data[coord + 1] = 0xff;
59            data[coord + 2] = 0xff;
60        }
61    }
62
63    codec.send_frame(&frame);
64
65    let mut packet = Packet::new();
66
67    codec.receive_packet(&mut packet);
68
69    format_ctx.write_frame(&mut packet);
70
71    packet.clear();
72
73    format_ctx.write_trailer();
74
75    println!("Hello, world!");
76}
Source

pub fn set_flags(&mut self, flags: i32)

Set codec flags

Examples found in repository?
examples/generate_black_square_512x512.rs (line 29)
4fn main() {
5    let filename = "bk.png";
6    let width = 512;
7    let height = 512;
8
9    let mut format_ctx =
10        FormatContext::new("image2", filename, None).expect("Failed to create FormatContext");
11
12    let mut codec = CodecContext::from_encoder_id(low_level::AVCodecID_AV_CODEC_ID_PNG)
13        .expect("Failed to create CodecContext");
14
15    let mut stream =
16        Stream::new(&mut format_ctx, Some(&*codec)).expect("Failed to create a stream");
17
18    codec
19        .set_size(width, height)
20        .set_framerate(1)
21        .set_pixel_format(low_level::AVPixelFormat_AV_PIX_FMT_RGB24)
22        .set_bitrate(400_000)
23        .set_gop_size(1)
24        .set_max_b_frames(1);
25
26    if (format_ctx.get_output_format().flags & low_level::AVFMT_GLOBALHEADER as i32) != 0 {
27        let flags = codec.get_flags() | low_level::AV_CODEC_FLAG_GLOBAL_HEADER as i32;
28
29        codec.set_flags(flags);
30    }
31
32    match codec.open(None) {
33        Err(err) => panic!("Error opening codec: {}", err),
34        Ok(()) => {}
35    };
36
37    codec.fill_stream_parameters(&mut stream);
38
39    match format_ctx.open(filename, AVIO_FLAG_WRITE as i32) {
40        Err(err) => panic!("Error opening file! {err}"),
41        Ok(()) => {}
42    };
43
44    format_ctx
45        .write_header(None)
46        .expect("Failed to write a header!");
47
48    let mut frame = Frame::from_size_and_pixfmt(width, height, AVPixelFormat_AV_PIX_FMT_RGB24)
49        .expect("Failed to make a frame!");
50
51    let data = frame.data_plane_mut(0).expect("Failed to get plane!");
52
53    for y in 0usize..height as usize {
54        for x in 0usize..width as usize {
55            let coord = y * (width as usize * 3usize) + (x * 3);
56
57            data[coord + 0] = 0xff;
58            data[coord + 1] = 0xff;
59            data[coord + 2] = 0xff;
60        }
61    }
62
63    codec.send_frame(&frame);
64
65    let mut packet = Packet::new();
66
67    codec.receive_packet(&mut packet);
68
69    format_ctx.write_frame(&mut packet);
70
71    packet.clear();
72
73    format_ctx.write_trailer();
74
75    println!("Hello, world!");
76}
Source

pub fn get_flags(&self) -> i32

Get codec flags

Examples found in repository?
examples/generate_black_square_512x512.rs (line 27)
4fn main() {
5    let filename = "bk.png";
6    let width = 512;
7    let height = 512;
8
9    let mut format_ctx =
10        FormatContext::new("image2", filename, None).expect("Failed to create FormatContext");
11
12    let mut codec = CodecContext::from_encoder_id(low_level::AVCodecID_AV_CODEC_ID_PNG)
13        .expect("Failed to create CodecContext");
14
15    let mut stream =
16        Stream::new(&mut format_ctx, Some(&*codec)).expect("Failed to create a stream");
17
18    codec
19        .set_size(width, height)
20        .set_framerate(1)
21        .set_pixel_format(low_level::AVPixelFormat_AV_PIX_FMT_RGB24)
22        .set_bitrate(400_000)
23        .set_gop_size(1)
24        .set_max_b_frames(1);
25
26    if (format_ctx.get_output_format().flags & low_level::AVFMT_GLOBALHEADER as i32) != 0 {
27        let flags = codec.get_flags() | low_level::AV_CODEC_FLAG_GLOBAL_HEADER as i32;
28
29        codec.set_flags(flags);
30    }
31
32    match codec.open(None) {
33        Err(err) => panic!("Error opening codec: {}", err),
34        Ok(()) => {}
35    };
36
37    codec.fill_stream_parameters(&mut stream);
38
39    match format_ctx.open(filename, AVIO_FLAG_WRITE as i32) {
40        Err(err) => panic!("Error opening file! {err}"),
41        Ok(()) => {}
42    };
43
44    format_ctx
45        .write_header(None)
46        .expect("Failed to write a header!");
47
48    let mut frame = Frame::from_size_and_pixfmt(width, height, AVPixelFormat_AV_PIX_FMT_RGB24)
49        .expect("Failed to make a frame!");
50
51    let data = frame.data_plane_mut(0).expect("Failed to get plane!");
52
53    for y in 0usize..height as usize {
54        for x in 0usize..width as usize {
55            let coord = y * (width as usize * 3usize) + (x * 3);
56
57            data[coord + 0] = 0xff;
58            data[coord + 1] = 0xff;
59            data[coord + 2] = 0xff;
60        }
61    }
62
63    codec.send_frame(&frame);
64
65    let mut packet = Packet::new();
66
67    codec.receive_packet(&mut packet);
68
69    format_ctx.write_frame(&mut packet);
70
71    packet.clear();
72
73    format_ctx.write_trailer();
74
75    println!("Hello, world!");
76}
Source

pub fn receive_packet(&mut self, out: &mut Packet) -> i32

Receive packet from codec to out

Examples found in repository?
examples/generate_black_square_512x512.rs (line 67)
4fn main() {
5    let filename = "bk.png";
6    let width = 512;
7    let height = 512;
8
9    let mut format_ctx =
10        FormatContext::new("image2", filename, None).expect("Failed to create FormatContext");
11
12    let mut codec = CodecContext::from_encoder_id(low_level::AVCodecID_AV_CODEC_ID_PNG)
13        .expect("Failed to create CodecContext");
14
15    let mut stream =
16        Stream::new(&mut format_ctx, Some(&*codec)).expect("Failed to create a stream");
17
18    codec
19        .set_size(width, height)
20        .set_framerate(1)
21        .set_pixel_format(low_level::AVPixelFormat_AV_PIX_FMT_RGB24)
22        .set_bitrate(400_000)
23        .set_gop_size(1)
24        .set_max_b_frames(1);
25
26    if (format_ctx.get_output_format().flags & low_level::AVFMT_GLOBALHEADER as i32) != 0 {
27        let flags = codec.get_flags() | low_level::AV_CODEC_FLAG_GLOBAL_HEADER as i32;
28
29        codec.set_flags(flags);
30    }
31
32    match codec.open(None) {
33        Err(err) => panic!("Error opening codec: {}", err),
34        Ok(()) => {}
35    };
36
37    codec.fill_stream_parameters(&mut stream);
38
39    match format_ctx.open(filename, AVIO_FLAG_WRITE as i32) {
40        Err(err) => panic!("Error opening file! {err}"),
41        Ok(()) => {}
42    };
43
44    format_ctx
45        .write_header(None)
46        .expect("Failed to write a header!");
47
48    let mut frame = Frame::from_size_and_pixfmt(width, height, AVPixelFormat_AV_PIX_FMT_RGB24)
49        .expect("Failed to make a frame!");
50
51    let data = frame.data_plane_mut(0).expect("Failed to get plane!");
52
53    for y in 0usize..height as usize {
54        for x in 0usize..width as usize {
55            let coord = y * (width as usize * 3usize) + (x * 3);
56
57            data[coord + 0] = 0xff;
58            data[coord + 1] = 0xff;
59            data[coord + 2] = 0xff;
60        }
61    }
62
63    codec.send_frame(&frame);
64
65    let mut packet = Packet::new();
66
67    codec.receive_packet(&mut packet);
68
69    format_ctx.write_frame(&mut packet);
70
71    packet.clear();
72
73    format_ctx.write_trailer();
74
75    println!("Hello, world!");
76}
Source

pub fn send_packet(&mut self, packet: &Packet) -> i32

Examples found in repository?
examples/decode_frame.rs (line 56)
11fn main() {
12    let url = if let Some(url) = std::env::args().skip(1).next() {
13        url
14    } else {
15        eprintln!("No input file!");
16        std::process::exit(1);
17    };
18
19    let mut format_context = FormatContext::open_input(&url).expect("Failed to open file!");
20
21    format_context.find_stream_info();
22
23    for i in format_context.streams() {
24        println!("{i:#?}");
25    }
26
27    let video_stream = format_context
28        .streams()
29        .filter(|x| x.codec_parameters().is_video())
30        .next()
31        .expect("Failed to find a video stream");
32
33    println!("CodecParams idx: {}", video_stream.index());
34    println!(
35        "CodecParams format: {}",
36        video_stream.codec_parameters().format()
37    );
38
39    let mut codec = CodecContext::from_decoder_id(video_stream.codec_parameters().codec_id())
40        .expect("Failed to create CodecContext");
41
42    codec.fill_from_parameters(&video_stream.codec_parameters());
43
44    codec.open(None).unwrap();
45
46    println!("Pixel format: {}", codec.get_pixel_format());
47
48    format_context.seek_msec(video_stream.index(), 4 * 60 * 1000);
49
50    let mut packet = Packet::new();
51
52    while format_context.read_frame(&mut packet) >= 0 {
53        println!("{}", packet.stream_index());
54
55        if packet.stream_index() == video_stream.index() {
56            codec.send_packet(&packet);
57
58            let mut frame = Frame::empty().expect("Failed to allocate a frame");
59
60            while codec.receive_frame(&mut frame) >= 0 {
61                println!("{}", frame.format());
62                {
63                    let (width, height) = video_stream.codec_parameters().size();
64                    println!("{width} x {height}");
65
66                    let mut new_frame =
67                        Frame::from_size_and_pixfmt(width, height, AVPixelFormat_AV_PIX_FMT_RGB24)
68                            .unwrap();
69
70                    let sws = Sws::new(
71                        width,
72                        height,
73                        video_stream.codec_parameters().format(),
74                        width,
75                        height,
76                        AVPixelFormat_AV_PIX_FMT_RGB24,
77                        SWS_BILINEAR as _,
78                    );
79
80                    println!("{:?} {:?}", frame.linesize(), new_frame.linesize());
81
82                    sws.scale(&frame, &mut new_frame);
83
84                    let mut file = std::fs::OpenOptions::new()
85                        .create(true)
86                        .truncate(true)
87                        .write(true)
88                        .open("data.bin")
89                        .unwrap();
90
91                    file.write(new_frame.data_plane(0).unwrap()).unwrap();
92                }
93            }
94
95            break;
96        }
97    }
98
99    println!("Exit!");
100}
Source

pub fn is_open(&self) -> bool

Returns true if codec is opened.

Source

pub unsafe fn raw_codec(&self) -> *const AVCodec

Source

pub unsafe fn raw_codec_context(&self) -> *const AVCodecContext

Trait Implementations§

Source§

impl Deref for Decoder

Source§

type Target = CodecContext

The resulting type after dereferencing.
Source§

fn deref(&self) -> &Self::Target

Dereferences the value.
Source§

impl DerefMut for Decoder

Source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

Source§

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)
The target type on which the method may be called.
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.