FFmpeg Next

https://docs.rs/ffmpeg-next/latest
Admin
FFmpeg Next is a Rust binding for the FFmpeg multimedia framework, providing access to its...
Tokens:428,892
Snippets:2,321
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Video Decoder Usage Examples

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/codec/decoder/video/struct.Video.html?search=u32+-%3E+bool

Examples demonstrating how to initialize a video decoder and access its properties such as width, height, and format for processing or transcoding.

```rust
11fn main() -> Result<(), ffmpeg::Error> {
12    ffmpeg::init().unwrap();
13
14    if let Ok(mut ictx) = input(&env::args().nth(1).expect("Cannot open file.")) {
15        let input = ictx
16            .streams()
17            .best(Type::Video)
18            .ok_or(ffmpeg::Error::StreamNotFound)?;
19        let video_stream_index = input.index();
20
21        let context_decoder = ffmpeg::codec::context::Context::from_parameters(input.parameters())?;
22        let mut decoder = context_decoder.decoder().video()?;
23
24        let mut scaler = Context::get(
25            decoder.format(),
26            decoder.width(),
27            decoder.height(),
28            Pixel::RGB24,
29            decoder.width(),
30            decoder.height(),
31            Flags::BILINEAR,
32        )?;
33
34        let mut frame_index = 0;
35
36        let mut receive_and_process_decoded_frames =
37            |decoder: &mut ffmpeg::decoder::Video| -> Result<(), ffmpeg::Error> {
38                let mut decoded = Video::empty();
39                while decoder.receive_frame(&mut decoded).is_ok() {
40                    let mut rgb_frame = Video::empty();
41                    scaler.run(&decoded, &mut rgb_frame)?;
42                    save_file(&rgb_frame, frame_index).unwrap();
43                    frame_index += 1;
44                }
45                Ok(())
46            };
47
48        for (stream, packet) in ictx.packets() {
49            if stream.index() == video_stream_index {
50                decoder.send_packet(&packet)?;
51                receive_and_process_decoded_frames(&mut decoder)?;
52            }
53        }
54        decoder.send_eof()?;
55        receive_and_process_decoded_frames(&mut decoder)?;
56    }
57
58    Ok(())
59}
```

```rust
43    fn new(
44        ist: &format::stream::Stream,
45        octx: &mut format::context::Output,
46        ost_index: usize,
47        x264_opts: Dictionary,
48        enable_logging: bool,
49    ) -> Result<Self, ffmpeg::Error> {
50        let global_header = octx.format().flags().contains(format::Flags::GLOBAL_HEADER);
51        let decoder = ffmpeg::codec::context::Context::from_parameters(ist.parameters())?
52            .decoder()
53            .video()?;
54
55        let codec = encoder::find(codec::Id::H264);
56        let mut ost = octx.add_stream(codec)?;
57
58        let mut encoder =
59            codec::context::Context::new_with_codec(codec.ok_or(ffmpeg::Error::InvalidData)?)
60                .encoder()
61                .video()?;
62        ost.set_parameters(&encoder);
63        encoder.set_height(decoder.height());
64        encoder.set_width(decoder.width());
65        encoder.set_aspect_ratio(decoder.aspect_ratio());
66        encoder.set_format(decoder.format());
67        encoder.set_frame_rate(decoder.frame_rate());
68        encoder.set_time_base(ist.time_base());
69
70        if global_header {
71            encoder.set_flags(codec::Flags::GLOBAL_HEADER);
72        }
73
74        let opened_encoder = encoder
75            .open_with(x264_opts)
76            .expect("error opening x264 with supplied settings");
77        ost.set_parameters(&opened_encoder);
78        Ok(Self {
79            ost_index,
80            decoder,
81            input_time_base: ist.time_base(),
82            encoder: opened_encoder,
83            logging_enabled: enable_logging,
84            frame_count: 0,
85            last_log_frame_count: 0,
86            starting_time: Instant::now(),
87            last_log_time: Instant::now(),
88        })
89    }
```

--------------------------------

### Call a documented function in an example

Source: https://docs.rs/ffmpeg-next/latest/scrape-examples-help.html

Example of how to invoke a library function within an example file to trigger automatic scraping.

```rust
// examples/ex.rs
fn main() {
  a_crate::a_func();
}
```

--------------------------------

### Initializing a Transcoder

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/format/context/output/struct.Output.html?search=

Example of the constructor for a custom Transcoder struct, showing how to access output context flags.

```rust
43    fn new(
44        ist: &format::stream::Stream,
45        octx: &mut format::context::Output,
46        ost_index: usize,
47        x264_opts: Dictionary,
48        enable_logging: bool,
49    ) -> Result<Self, ffmpeg::Error> {
50        let global_header = octx.format().flags().contains(format::Flags::GLOBAL_HEADER);
```

--------------------------------

### Remuxing Media Files

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/codec/packet/packet/struct.Packet.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

A complete example showing how to initialize input/output contexts, map streams, and copy packets between containers.

```rust
fn main() {
    let input_file = env::args().nth(1).expect("missing input file");
    let output_file = env::args().nth(2).expect("missing output file");

    ffmpeg::init().unwrap();
    log::set_level(log::Level::Warning);

    let mut ictx = format::input(&input_file).unwrap();
    let mut octx = format::output(&output_file).unwrap();

    let mut stream_mapping = vec![0; ictx.nb_streams() as _];
    let mut ist_time_bases = vec![Rational(0, 1); ictx.nb_streams() as _];
    let mut ost_index = 0;
    for (ist_index, ist) in ictx.streams().enumerate() {
        let ist_medium = ist.parameters().medium();
        if ist_medium != media::Type::Audio
            && ist_medium != media::Type::Video
            && ist_medium != media::Type::Subtitle
        {
            stream_mapping[ist_index] = -1;
            continue;
        }
        stream_mapping[ist_index] = ost_index;
        ist_time_bases[ist_index] = ist.time_base();
        ost_index += 1;
        let mut ost = octx.add_stream(encoder::find(codec::Id::None)).unwrap();
        ost.set_parameters(ist.parameters());
        // We need to set codec_tag to 0 lest we run into incompatible codec tag
        // issues when muxing into a different container format. Unfortunately
        // there's no high level API to do this (yet).
        unsafe {
            (*ost.parameters().as_mut_ptr()).codec_tag = 0;
        }
    }

    octx.set_metadata(ictx.metadata().to_owned());
    octx.write_header().unwrap();

    for (stream, mut packet) in ictx.packets() {
        let ist_index = stream.index();
        let ost_index = stream_mapping[ist_index];
        if ost_index < 0 {
            continue;
        }
        let ost = octx.stream(ost_index as _).unwrap();
        packet.rescale_ts(ist_time_bases[ist_index], ost.time_base());
        packet.set_position(-1);
        packet.set_stream(ost_index as _);
        packet.write_interleaved(&mut octx).unwrap();
    }

    octx.write_trailer().unwrap();
}
```

--------------------------------

### Decode Video Frames

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/codec/decoder/decoder/struct.Decoder.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example demonstrating how to initialize a video decoder and process frames from a stream.

```rust
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(())
}
```

--------------------------------

### Configure Filter Sink

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/filter/context/struct.Context.html

Example of setting up a filter graph and configuring the sink for audio transcoding.

```rust
fn filter(
    spec: &str,
    decoder: &codec::decoder::Audio,
    encoder: &codec::encoder::Audio,
) -> Result<filter::Graph, ffmpeg::Error> {
    let mut filter = filter::Graph::new();

    let args = format!(
        "time_base={}:sample_rate={}:sample_fmt={}:channel_layout=0x{:x}",
        decoder.time_base(),
        decoder.rate(),
        decoder.format().name(),
        decoder.channel_layout().bits()
    );

    filter.add(&filter::find("abuffer").unwrap(), "in", &args)?;
    filter.add(&filter::find("abuffersink").unwrap(), "out", "");

    {
        let mut out = filter.get("out").unwrap();

        out.set_sample_format(encoder.format());
        out.set_channel_layout(encoder.channel_layout());
        out.set_sample_rate(encoder.rate());
    }

    filter.output("in", 0)?.input("out", 0)?.parse(spec)?;
    filter.validate()?;

    println!("{}", filter.dump());

    if let Some(codec) = encoder.codec()
        && !codec
            .capabilities()
            .contains(ffmpeg::codec::capabilities::Capabilities::VARIABLE_FRAME_SIZE)
    {
        filter
            .get("out")
            .unwrap()
            .sink()
            .set_frame_size(encoder.frame_size());
    }

    Ok(filter)
}

struct Transcoder {
    stream: usize,
    filter: filter::Graph,
    decoder: codec::decoder::Audio,
    encoder: codec::encoder::Audio,
    in_time_base: ffmpeg::Rational,
    out_time_base: ffmpeg::Rational,
}

fn transcoder<P: AsRef<Path> + ?Sized>(
    ictx: &mut format::context::Input,
    octx: &mut format::context::Output,
    path: &P,
    filter_spec: &str,
) -> Result<Transcoder, ffmpeg::Error> {
    let input = ictx
        .streams()
        .best(media::Type::Audio)
        .expect("could not find best audio stream");
    let context = ffmpeg::codec::context::Context::from_parameters(input.parameters())?;
    let mut decoder = context.decoder().audio()?;
    let codec = ffmpeg::encoder::find(octx.format().codec(path, media::Type::Audio))
        .expect("failed to find encoder")
        .audio()?;
    let global = octx
        .format()
        .flags()
        .contains(ffmpeg::format::flag::Flags::GLOBAL_HEADER);

    decoder.set_parameters(input.parameters())?;

    let mut output = octx.add_stream(codec)?;
    let context = ffmpeg::codec::context::Context::from_parameters(output.parameters())?;
    let mut encoder = context.encoder().audio()?;

    let channel_layout = codec
        .channel_layouts()
        .map(|cls| cls.best(decoder.channel_layout().channels()))
        .unwrap_or(ffmpeg::channel_layout::ChannelLayout::STEREO);

    if global {
        encoder.set_flags(ffmpeg::codec::flag::Flags::GLOBAL_HEADER);
    }

    encoder.set_rate(decoder.rate() as i32);
    encoder.set_channel_layout(channel_layout);
    #[cfg(not(feature = "ffmpeg_7_0"))]
    {
        encoder.set_channels(channel_layout.channels());
    }
    encoder.set_format(
        codec
            .formats()
            .expect("unknown supported formats")
            .next()
            .unwrap(),
    );
    encoder.set_bit_rate(decoder.bit_rate());
    encoder.set_max_bit_rate(decoder.max_bit_rate());

    encoder.set_time_base((1, decoder.rate() as i32));
    output.set_time_base((1, decoder.rate() as i32));

    let encoder = encoder.open_as(codec)?;
    output.set_parameters(&encoder);

    let filter = filter(filter_spec, &decoder, &encoder)?;

    let in_time_base = decoder.time_base();
    let out_time_base = output.time_base();

    Ok(Transcoder {
        stream: input.index(),
        filter,
        decoder,
        encoder,
        in_time_base,
    })
```

--------------------------------

### Initialize FFmpeg in a transcoding application

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/fn.init.html

Call ffmpeg::init() at the start of the main function to prepare the library for processing.

```rust
fn main() {
    ffmpeg::init().unwrap();

    let input = env::args().nth(1).expect("missing input");
    let output = env::args().nth(2).expect("missing output");
    let filter = env::args().nth(3).unwrap_or_else(|| "anull".to_owned());
    let seek = env::args().nth(4).and_then(|s| s.parse::<i64>().ok());

    let mut ictx = format::input(&input).unwrap();
    let mut octx = format::output(&output).unwrap();
    let mut transcoder = transcoder(&mut ictx, &mut octx, &output, &filter).unwrap();

    if let Some(position) = seek {
        // If the position was given in seconds, rescale it to ffmpegs base timebase.
        let position = position.rescale((1, 1), rescale::TIME_BASE);
        // If this seek was embedded in the transcoding loop, a call of `flush()`
        // for every opened buffer after the successful seek would be advisable.
        ictx.seek(position, ..position).unwrap();
    }

    octx.set_metadata(ictx.metadata().to_owned());
    octx.write_header().unwrap();

    for (stream, mut packet) in ictx.packets() {
        if stream.index() == transcoder.stream {
            packet.rescale_ts(stream.time_base(), transcoder.in_time_base);
            transcoder.send_packet_to_decoder(&packet);
            transcoder.receive_and_process_decoded_frames(&mut octx);
        }
    }

    transcoder.send_eof_to_decoder();
    transcoder.receive_and_process_decoded_frames(&mut octx);

    transcoder.flush_filter();
    transcoder.get_and_process_filtered_frames(&mut octx);

    transcoder.send_eof_to_encoder();
    transcoder.receive_and_process_encoded_packets(&mut octx);

    octx.write_trailer().unwrap();
}
```

```rust
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(())
}
```

--------------------------------

### Inspect Audio Codec Properties

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/codec/audio/struct.Audio.html?search=u32+-%3E+bool

Example demonstrating how to retrieve and print audio codec details like rates, formats, and channel layouts from a decoder or encoder.

```rust
5fn main() {
6    ffmpeg::init().unwrap();
7
8    for arg in env::args().skip(1) {
9        if let Some(codec) = ffmpeg::decoder::find_by_name(&arg) {
10            println!("type: decoder");
11            println!("\t id: {:?}", codec.id());
12            println!("\t name: {}", codec.name());
13            println!("\t description: {}", codec.description());
14            println!("\t medium: {:?}", codec.medium());
15            println!("\t capabilities: {:?}", codec.capabilities());
16
17            if let Some(profiles) = codec.profiles() {
18                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
19            } else {
20                println!("\t profiles: none");
21            }
22
23            if let Ok(video) = codec.video() {
24                if let Some(rates) = video.rates() {
25                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
26                } else {
27                    println!("\t rates: any");
28                }
29
30                if let Some(formats) = video.formats() {
31                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
32                } else {
33                    println!("\t formats: any");
34                }
35            }
36
37            if let Ok(audio) = codec.audio() {
38                if let Some(rates) = audio.rates() {
39                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
40                } else {
41                    println!("\t rates: any");
42                }
43
44                if let Some(formats) = audio.formats() {
45                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
46                } else {
47                    println!("\t formats: any");
48                }
49
50                if let Some(layouts) = audio.channel_layouts() {
51                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
52                } else {
53                    println!("\t channel_layouts: any");
54                }
55            }
56
57            println!("\t max_lowres: {:?}", codec.max_lowres());
58        }
59
60        if let Some(codec) = ffmpeg::encoder::find_by_name(&arg) {
61            println!();
62            println!("type: encoder");
63            println!("\t id: {:?}", codec.id());
64            println!("\t name: {}", codec.name());
65            println!("\t description: {}", codec.description());
66            println!("\t medium: {:?}", codec.medium());
67            println!("\t capabilities: {:?}", codec.capabilities());
68
69            if let Some(profiles) = codec.profiles() {
70                println!("\t profiles: {:?}", profiles.collect::<Vec<_>>());
71            }
72
73            if let Ok(video) = codec.video() {
74                if let Some(rates) = video.rates() {
75                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
76                } else {
77                    println!("\t rates: any");
78                }
79
80                if let Some(formats) = video.formats() {
81                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
82                } else {
83                    println!("\t formats: any");
84                }
85            }
86
87            if let Ok(audio) = codec.audio() {
88                if let Some(rates) = audio.rates() {
89                    println!("\t rates: {:?}", rates.collect::<Vec<_>>());
90                } else {
91                    println!("\t rates: any");
92                }
93
94                if let Some(formats) = audio.formats() {
95                    println!("\t formats: {:?}", formats.collect::<Vec<_>>());
96                } else {
97                    println!("\t formats: any");
98                }
99
100                if let Some(layouts) = audio.channel_layouts() {
101                    println!("\t channel_layouts: {:?}", layouts.collect::<Vec<_>>());
102                } else {
103                    println!("\t channel_layouts: any");
104                }
105            }
106
107            println!("\t max_lowres: {:?}", codec.max_lowres());
108        }
109    }
110}
```

--------------------------------

### Stream Mapping and Transcoding Setup

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/format/context/output/struct.Output.html?search=u32+-%3E+bool

Iterates through input streams to initialize transcoders for video or configure stream copying for other media types.

```rust
191        .best(media::Type::Video)
192        .map(|stream| stream.index());
193    let mut stream_mapping: Vec<isize> = vec![0; ictx.nb_streams() as _];
194    let mut ist_time_bases = vec![Rational(0, 0); ictx.nb_streams() as _];
195    let mut ost_time_bases = vec![Rational(0, 0); ictx.nb_streams() as _];
196    let mut transcoders = HashMap::new();
197    let mut ost_index = 0;
198    for (ist_index, ist) in ictx.streams().enumerate() {
199        let ist_medium = ist.parameters().medium();
200        if ist_medium != media::Type::Audio
201            && ist_medium != media::Type::Video
202            && ist_medium != media::Type::Subtitle
203        {
204            stream_mapping[ist_index] = -1;
205            continue;
206        }
207        stream_mapping[ist_index] = ost_index;
208        ist_time_bases[ist_index] = ist.time_base();
209        if ist_medium == media::Type::Video {
210            // Initialize transcoder for video stream.
211            transcoders.insert(
212                ist_index,
213                Transcoder::new(
214                    &ist,
215                    &mut octx,
216                    ost_index as _,
217                    x264_opts.to_owned(),
218                    Some(ist_index) == best_video_stream_index,
219                )
220                .unwrap(),
221            );
222        } else {
223            // Set up for stream copy for non-video stream.
224            let mut ost = octx.add_stream(encoder::find(codec::Id::None)).unwrap();
225            ost.set_parameters(ist.parameters());
226            // We need to set codec_tag to 0 lest we run into incompatible codec tag
227            // issues when muxing into a different container format. Unfortunately
228            // there's no high level API to do this (yet).
229            unsafe {
230                (*ost.parameters().as_mut_ptr()).codec_tag = 0;
231            }
232        }
233        ost_index += 1;
234    }
```

--------------------------------

### Audio Transcoding Setup

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/format/stream/struct.Stream.html?search=

Configures an audio transcoding pipeline by initializing decoders, encoders, and filters based on input parameters.

```rust
64fn transcoder<P: AsRef<Path> + ?Sized>(
65    ictx: &mut format::context::Input,
66    octx: &mut format::context::Output,
67    path: &P,
68    filter_spec: &str,
69) -> Result<Transcoder, ffmpeg::Error> {
70    let input = ictx
71        .streams()
72        .best(media::Type::Audio)
73        .expect("could not find best audio stream");
74    let context = ffmpeg::codec::context::Context::from_parameters(input.parameters())?;
75    let mut decoder = context.decoder().audio()?;
76    let codec = ffmpeg::encoder::find(octx.format().codec(path, media::Type::Audio))
77        .expect("failed to find encoder")
78        .audio()?;
79    let global = octx
80        .format()
81        .flags()
82        .contains(ffmpeg::format::flag::Flags::GLOBAL_HEADER);
83
84    decoder.set_parameters(input.parameters())?;
85
86    let mut output = octx.add_stream(codec)?;
87    let context = ffmpeg::codec::context::Context::from_parameters(output.parameters())?;
88    let mut encoder = context.encoder().audio()?;
89
90    let channel_layout = codec
91        .channel_layouts()
92        .map(|cls| cls.best(decoder.channel_layout().channels()))
93        .unwrap_or(ffmpeg::channel_layout::ChannelLayout::STEREO);
94
95    if global {
96        encoder.set_flags(ffmpeg::codec::flag::Flags::GLOBAL_HEADER);
97    }
98
99    encoder.set_rate(decoder.rate() as i32);
100    encoder.set_channel_layout(channel_layout);
101    #[cfg(not(feature = "ffmpeg_7_0"))]
102    {
103        encoder.set_channels(channel_layout.channels());
104    }
105    encoder.set_format(
106        codec
107            .formats()
108            .expect("unknown supported formats")
109            .next()
110            .unwrap(),
111    );
112    encoder.set_bit_rate(decoder.bit_rate());
113    encoder.set_max_bit_rate(decoder.max_bit_rate());
114
115    encoder.set_time_base((1, decoder.rate() as i32));
116    output.set_time_base((1, decoder.rate() as i32));
117
118    let encoder = encoder.open_as(codec)?;
119    output.set_parameters(&encoder);
120
121    let filter = filter(filter_spec, &decoder, &encoder)?;
122
123    let in_time_base = decoder.time_base();
124    let out_time_base = output.time_base();
125
126    Ok(Transcoder {
127        stream: input.index(),
128        filter,
129        decoder,
130        encoder,
131        in_time_base,
132        out_time_base,
133    })
134}
135
136impl Transcoder {
137    fn send_frame_to_encoder(&mut self, frame: &ffmpeg::Frame) {
138        self.encoder.send_frame(frame).unwrap();
139    }
140
141    fn send_eof_to_encoder(&mut self) {
142        self.encoder.send_eof().unwrap();
143    }
144
145    fn receive_and_process_encoded_packets(&mut self, octx: &mut format::context::Output) {
```

--------------------------------

### Main Execution Entry Point

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/format/context/output/struct.Output.html?search=

Initializes the FFmpeg environment and sets up input/output contexts.

```rust
fn main() {
    let input_file = env::args().nth(1).expect("missing input file");
    let output_file = env::args().nth(2).expect("missing output file");
    let x264_opts = parse_opts(
        env::args()
            .nth(3)
            .unwrap_or_else(|| DEFAULT_X264_OPTS.to_string()),
    )
    .expect("invalid x264 options string");

    eprintln!("x264 options: {:?}", x264_opts);

    ffmpeg::init().unwrap();
    log::set_level(log::Level::Info);

    let mut ictx = format::input(&input_file).unwrap();
    let mut octx = format::output(&output_file).unwrap();

    format::context::input::dump(&ictx, 0, Some(&input_file));

    let best_video_stream_index = ictx
        .streams()
```

--------------------------------

### Get metadata values

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/util/dictionary/struct.Mut.html?search=std%3A%3Avec

Example of using the get method to retrieve specific metadata values from a chapter.

```rust
5fn main() {
6    ffmpeg::init().unwrap();
7
8    match ffmpeg::format::input(&env::args().nth(1).expect("missing input file name")) {
9        Ok(ictx) => {
10            println!("Nb chapters: {}", ictx.nb_chapters());
11
12            for chapter in ictx.chapters() {
13                println!("chapter id {}:", chapter.id());
14                println!("\ttime_base: {}", chapter.time_base());
15                println!("\tstart: {}", chapter.start());
16                println!("\tend: {}", chapter.end());
17
18                for (k, v) in chapter.metadata().iter() {
19                    println!("\t{}: {}", k, v);
20                }
21            }
22
23            let mut octx = ffmpeg::format::output(&"test.mkv").expect("Couldn't open test file");
24
25            for chapter in ictx.chapters() {
26                let title = match chapter.metadata().get("title") {
27                    Some(title) => String::from(title),
28                    None => String::new(),
29                };
30
31                match octx.add_chapter(
32                    chapter.id(),
33                    chapter.time_base(),
34                    chapter.start(),
35                    chapter.end(),
36                    &title,
37                ) {
38                    Ok(chapter) => println!("Added chapter with id {} to output", chapter.id()),
39                    Err(error) => {
40                        println!("Error adding chapter with id: {} - {}", chapter.id(), error)
41                    }
42                }
43            }
44
45            println!("\nOuput: nb chapters: {}", octx.nb_chapters());
46            for chapter in octx.chapters() {
47                println!("chapter id {}:", chapter.id());
48                println!("\ttime_base: {}", chapter.time_base());
49                println!("\tstart: {}", chapter.start());
50                println!("\tend: {}", chapter.end());
51                for (k, v) in octx.chapters() {
52                    println!("\t{}: {}", k, v);
53                }
54            }
55        }
56
57        Err(error) => println!("error: {}", error),
58    }
59}
```

--------------------------------

### Subtitle::start / set_start

Source: https://docs.rs/ffmpeg-next/latest/src/ffmpeg_next/codec/subtitle/mod.rs.html?search=std%3A%3Avec

Methods to get or set the start display time of the subtitle.

```APIDOC
### fn start(&self) -> u32
Returns the start display time.

### fn set_start(&mut self, value: u32)
Sets the start display time.
```

--------------------------------

### fn output_as_with

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/format/fn.output_as_with.html?search=

Creates an output format context using the specified path, format string, and dictionary options.

```APIDOC
## Function: output_as_with

### Signature
`pub fn output_as_with<P: AsRef<Path> + ?Sized>(path: &P, format: &str, options: Dictionary<'_>) -> Result<Output, Error>`

### Description
Initializes an output context for a given file path with a specified format and custom options provided as a dictionary.

### Parameters
- **path** (&P) - The file path for the output.
- **format** (&str) - The format string to be used for the output.
- **options** (Dictionary<'_>) - A dictionary of options to configure the output format.

### Returns
- **Result<Output, Error>** - Returns an `Output` object on success, or an `Error` if the operation fails.
```

--------------------------------

### fn init()

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/format/network/fn.init.html?search=std%3A%3Avec

Initializes the network format components for ffmpeg_next.

```APIDOC
## fn init()

### Description
Initializes the network format components. This function should be called to prepare network-related functionality within the library.

### Signature
`pub fn init()`
```

--------------------------------

### fn start(&self) -> Option<&T>

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/util/range/trait.Range.html?search=

Returns the start boundary of the range, if it exists.

```APIDOC
### fn start(&self) -> Option<&T>

Returns the start boundary of the range as an Option reference. If the range does not have a defined start, it returns None.
```

--------------------------------

### output_as_with

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/format/fn.output_as_with.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates an output format context for a given path, format, and set of options.

```APIDOC
## Function: output_as_with

### Signature
`pub fn output_as_with<P: AsRef<Path> + ?Sized>(path: &P, format: &str, options: Dictionary<'_>) -> Result<Output, Error>`

### Description
Creates an output format context for the specified path using the provided format string and dictionary options.

### Parameters
- **path** (&P) - The file path for the output.
- **format** (&str) - The format identifier string.
- **options** (Dictionary<'_>) - A dictionary of options to configure the output.

### Returns
- **Result<Output, Error>** - Returns an Output object on success, or an Error if the operation fails.
```

--------------------------------

### pub fn start(&self) -> i64

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/format/chapter/struct.ChapterMut.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the start timestamp of the chapter.

```APIDOC
## pub fn start(&self) -> i64

### Description
Returns the start timestamp of the chapter as an i64 value.

### Returns
- **i64** - The start timestamp of the chapter.
```

--------------------------------

### Create Output Context with Options

Source: https://docs.rs/ffmpeg-next/latest/src/ffmpeg_next/format/mod.rs.html?search=

Initializes an output context from a path and format string with provided dictionary options.

```rust
pub fn output_as_with<P: AsRef<Path> + ?Sized>(
    path: &P,
    format: &str,
    options: Dictionary,
) -> Result<context::Output, Error> {
    unsafe {
        let mut ps = ptr::null_mut();
        let path = from_path(path);
        let format = CString::new(format).unwrap();
        let mut opts = options.disown();

        match avformat_alloc_output_context2(
            &mut ps,
            ptr::null_mut(),
            format.as_ptr(),
            path.as_ptr(),
        ) {
            0 => {
                let res = avio_open2(
                    &mut (*ps).pb,
                    path.as_ptr(),
                    AVIO_FLAG_WRITE,
                    ptr::null(),
                    &mut opts,
                );

                Dictionary::own(opts);

                match res {
                    0 => Ok(context::Output::wrap(ps)),
                    e => Err(Error::from(e)),
                }
            }

            e => Err(Error::from(e)),
        }
    }
}
```

--------------------------------

### set_start

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/format/chapter/struct.ChapterMut.html

Sets the start time of the chapter.

```APIDOC
pub fn set_start(&mut self, value: i64)
```

--------------------------------

### init

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/format/network/index.html

Initializes the network library components.

```APIDOC
## fn init

### Description
Initializes the network library components required for FFmpeg network operations.

### Signature
`pub fn init()`
```

--------------------------------

### fn init()

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/format/network/fn.init.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes the network format module for ffmpeg-next.

```APIDOC
## fn init()

### Description
Initializes the network components required for ffmpeg-next operations.

### Signature
`pub fn init()`
```

--------------------------------

### get

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/codec/subtitle/struct.AssMut.html?search=u32+-%3E+bool

Retrieves the current subtitle value.

```APIDOC
## pub fn get(&self) -> &str

### Description
Returns the current content of the subtitle as a string slice.
```

--------------------------------

### init()

Source: https://docs.rs/ffmpeg-next/latest/src/ffmpeg_next/format/network.rs.html?search=

Initializes the network library for FFmpeg format operations.

```APIDOC
## fn init()

### Description
Initializes the network library. This should be called before performing any network-related operations in FFmpeg.

### Signature
`pub fn init()`
```

--------------------------------

### Subtitle::set_start

Source: https://docs.rs/ffmpeg-next/latest/src/ffmpeg_next/codec/subtitle/mod.rs.html?search=u32+-%3E+bool

Sets the start display time.

```APIDOC
### pub fn set_start(&mut self, value: u32)

Sets the start display time of the subtitle.
```

--------------------------------

### output_as_with

Source: https://docs.rs/ffmpeg-next/latest/src/ffmpeg_next/format/mod.rs.html

Creates an output context with a specified format and custom dictionary options.

```APIDOC
## fn output_as_with<P: AsRef<Path> + ?Sized>(path: &P, format: &str, options: Dictionary) -> Result<context::Output, Error>

### Description
Initializes an output context for a given file path using a specific format and a set of dictionary options.

### Parameters
- **path** (&P) - Required - The destination file path.
- **format** (&str) - Required - The name of the output format (muxer).
- **options** (Dictionary) - Required - A dictionary of options to pass to the muxer.

### Returns
- **Result<context::Output, Error>** - Returns an Output context on success, or an Error if initialization fails.
```

--------------------------------

### Subtitle::start

Source: https://docs.rs/ffmpeg-next/latest/src/ffmpeg_next/codec/subtitle/mod.rs.html?search=u32+-%3E+bool

Retrieves the start display time.

```APIDOC
### pub fn start(&self) -> u32

Returns the start display time of the subtitle.
```

--------------------------------

### get

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/util/dictionary/struct.Mut.html?search=std%3A%3Avec

Retrieves the value associated with a given key.

```APIDOC
## pub fn get(&'a self, key: &str) -> Option<&'a str>

### Description
Retrieves the value associated with the specified key from the dictionary, if it exists.

### Parameters
- **key** (&str) - The key to look up.

### Returns
- **Option<&'a str>** - The value associated with the key, or None if the key is not found.
```

--------------------------------

### fn output_with

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/format/fn.output_with.html?search=

Creates an output format context for the specified path using the provided dictionary of options.

```APIDOC
## fn output_with

### Signature
`pub fn output_with<P: AsRef<Path> + ?Sized>(path: &P, options: Dictionary<'_>) -> Result<Output, Error>`

### Description
Creates an output format context for the specified path, applying the provided dictionary of options to the output format.

### Parameters
- **path** (&P) - The file path or URL for the output.
- **options** (Dictionary<'_>) - A dictionary of options to configure the output format.

### Returns
- **Result<Output, Error>** - Returns an `Output` object on success, or an `Error` if the operation fails.
```

--------------------------------

### Initialize and Configure Audio Transcoder

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/codec/context/struct.Context.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates setting up audio decoder and encoder contexts from stream parameters and configuring codec properties like bit rate, channel layout, and time base.

```rust
fn transcoder<P: AsRef<Path> + ?Sized>(
    ictx: &mut format::context::Input,
    octx: &mut format::context::Output,
    path: &P,
    filter_spec: &str,
) -> Result<Transcoder, ffmpeg::Error> {
    let input = ictx
        .streams()
        .best(media::Type::Audio)
        .expect("could not find best audio stream");
    let context = ffmpeg::codec::context::Context::from_parameters(input.parameters())?;
    let mut decoder = context.decoder().audio()?;
    let codec = ffmpeg::encoder::find(octx.format().codec(path, media::Type::Audio))
        .expect("failed to find encoder")
        .audio()?;
    let global = octx
        .format()
        .flags()
        .contains(ffmpeg::format::flag::Flags::GLOBAL_HEADER);

    decoder.set_parameters(input.parameters())?;

    let mut output = octx.add_stream(codec)?;
    let context = ffmpeg::codec::context::Context::from_parameters(output.parameters())?;
    let mut encoder = context.encoder().audio()?;

    let channel_layout = codec
        .channel_layouts()
        .map(|cls| cls.best(decoder.channel_layout().channels()))
        .unwrap_or(ffmpeg::channel_layout::ChannelLayout::STEREO);

    if global {
        encoder.set_flags(ffmpeg::codec::flag::Flags::GLOBAL_HEADER);
    }

    encoder.set_rate(decoder.rate() as i32);
    encoder.set_channel_layout(channel_layout);
    #[cfg(not(feature = "ffmpeg_7_0"))]
    {
        encoder.set_channels(channel_layout.channels());
    }
    encoder.set_format(
        codec
            .formats()
            .expect("unknown supported formats")
            .next()
            .unwrap(),
    );
    encoder.set_bit_rate(decoder.bit_rate());
    encoder.set_max_bit_rate(decoder.max_bit_rate());

    encoder.set_time_base((1, decoder.rate() as i32));
    output.set_time_base((1, decoder.rate() as i32));

    let encoder = encoder.open_as(codec)?;
    output.set_parameters(&encoder);

    let filter = filter(filter_spec, &decoder, &encoder)?;

    let in_time_base = decoder.time_base();
    let out_time_base = output.time_base();

    Ok(Transcoder {
        stream: input.index(),
        filter,
        decoder,
        encoder,
        in_time_base,
        out_time_base,
    })
}
```

--------------------------------

### Range::start

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/util/range/trait.Range.html

Returns the start value of the range if it exists.

```APIDOC
## fn start(&self) -> Option<&T>

### Description
Returns the start bound of the range as an Option reference. If the range does not have a defined start, it returns None.

### Signature
`fn start(&self) -> Option<&T>`
```

--------------------------------

### get(&self) -> &str

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/codec/subtitle/struct.AssMut.html

Retrieves the current subtitle text.

```APIDOC
### get(&self) -> &str

Returns the current subtitle text as a string slice.
```

--------------------------------

### Transcoding and Stream Copying Workflow

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/codec/encoder/fn.find.html?search=std%3A%3Avec

This snippet shows the full process of setting up input/output contexts, configuring transcoders for video, and performing stream copying for other media types.

```rust
let x264_opts = parse_opts(
        env::args()
            .nth(3)
            .unwrap_or_else(|| DEFAULT_X264_OPTS.to_string()),
    )
    .expect("invalid x264 options string");

    eprintln!("x264 options: {:?}", x264_opts);

    ffmpeg::init().unwrap();
    log::set_level(log::Level::Info);

    let mut ictx = format::input(&input_file).unwrap();
    let mut octx = format::output(&output_file).unwrap();

    format::context::input::dump(&ictx, 0, Some(&input_file));

    let best_video_stream_index = ictx
        .streams()
        .best(media::Type::Video)
        .map(|stream| stream.index());
    let mut stream_mapping: Vec<isize> = vec![0; ictx.nb_streams() as _];
    let mut ist_time_bases = vec![Rational(0, 0); ictx.nb_streams() as _];
    let mut ost_time_bases = vec![Rational(0, 0); ictx.nb_streams() as _];
    let mut transcoders = HashMap::new();
    let mut ost_index = 0;
    for (ist_index, ist) in ictx.streams().enumerate() {
        let ist_medium = ist.parameters().medium();
        if ist_medium != media::Type::Audio
            && ist_medium != media::Type::Video
            && ist_medium != media::Type::Subtitle
        {
            stream_mapping[ist_index] = -1;
            continue;
        }
        stream_mapping[ist_index] = ost_index;
        ist_time_bases[ist_index] = ist.time_base();
        if ist_medium == media::Type::Video {
            // Initialize transcoder for video stream.
            transcoders.insert(
                ist_index,
                Transcoder::new(
                    &ist,
                    &mut octx,
                    ost_index as _,
                    x264_opts.to_owned(),
                    Some(ist_index) == best_video_stream_index,
                )
                .unwrap(),
            );
        } else {
            // Set up for stream copy for non-video stream.
            let mut ost = octx.add_stream(encoder::find(codec::Id::None)).unwrap();
            ost.set_parameters(ist.parameters());
            // We need to set codec_tag to 0 lest we run into incompatible codec tag
            // issues when muxing into a different container format. Unfortunately
            // there's no high level API to do this (yet).
            unsafe {
                (*ost.parameters().as_mut_ptr()).codec_tag = 0;
            }
        }
        ost_index += 1;
    }

    octx.set_metadata(ictx.metadata().to_owned());
    format::context::output::dump(&octx, 0, Some(&output_file));
    octx.write_header().unwrap();

    for (ost_index, _) in octx.streams().enumerate() {
        ost_time_bases[ost_index] = octx.stream(ost_index as _).unwrap().time_base();
    }

    for (stream, mut packet) in ictx.packets() {
        let ist_index = stream.index();
        let ost_index = stream_mapping[ist_index];
        if ost_index < 0 {
            continue;
        }
        let ost_time_base = ost_time_bases[ost_index as usize];
        match transcoders.get_mut(&ist_index) {
            Some(transcoder) => {
                transcoder.send_packet_to_decoder(&packet);
                transcoder.receive_and_process_decoded_frames(&mut octx, ost_time_base);
            }
            None => {
                // Do stream copy on non-video streams.
                packet.rescale_ts(ist_time_bases[ist_index], ost_time_base);
                packet.set_position(-1);
                packet.set_stream(ost_index as _);
                packet.write_interleaved(&mut octx).unwrap();
            }
        }
    }

    // Flush encoders and decoders.
    for (ost_index, transcoder) in transcoders.iter_mut() {
        let ost_time_base = ost_time_bases[*ost_index];
        transcoder.send_eof_to_decoder();
        transcoder.receive_and_process_decoded_frames(&mut octx, ost_time_base);
        transcoder.send_eof_to_encoder();
        transcoder.receive_and_process_encoded_packets(&mut octx, ost_time_base);
    }

    octx.write_trailer().unwrap();
}
```

--------------------------------

### Get current time

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/util/time/fn.current.html?search=

Returns the current time as a 64-bit integer.

```rust
pub fn current() -> i64
```

--------------------------------

### fn output_with

Source: https://docs.rs/ffmpeg-next/latest/ffmpeg_next/format/fn.output_with.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates an output context using the provided path and dictionary options.

```APIDOC
## Function: output_with

### Description
Creates an output context for a given path with specified dictionary options.

### Signature
`pub fn output_with<P: AsRef<Path> + ?Sized>(path: &P, options: Dictionary<'_>) -> Result<Output, Error>`

### Parameters
- **path** (&P) - The path to the output file or resource.
- **options** (Dictionary<'_>) - A dictionary of options to configure the output.

### Returns
- **Result<Output, Error>** - Returns an `Output` object on success, or an `Error` if the operation fails.
```
Tokens:
Raw