Example for mix audio and video?

[niuhuan]

I want the same effect as this command line, but I don't know how to make it

ffmpeg -i 1.video -i 1.audio -vcodec copy -acodec copy output.mp4

    let video_file = "1.video".to_owned();
    let audio_file = "1.audio".to_owned();
    let mix_file = "1.mp4".to_owned();
    let mut video_input = ffmpeg::format::input(&video_file).unwrap();
    let mut audio_input = ffmpeg::format::input(&audio_file).unwrap();
    let mut mix_output = ffmpeg::format::output(&mix_file).unwrap();
    video_input
        .streams()
        .best(ffmpeg::media::Type::Video)
        .map(|stream| {
            // ????
        });
    let best_audio_stream_index = audio_input
        .streams()
        .best(ffmpeg::media::Type::Audio)
        .map(|stream| stream.index());
    

mix_output.set_metadata()
mix_output.........

I don't know what to do with it

extern crate ffmpeg_next as ffmpeg;

use std::path::Path;
use ffmpeg::{format, media};
use anyhow::{Context, Result};

const audio: &str = "/Volumes/DATA/Downloads/a.audio";
const video: &str = "/Volumes/DATA/Downloads/a.video";
const merge: &str = "/Volumes/DATA/Downloads/a.mp4";

fn main() {
    let mut audio_input = format::input(&audio.to_string()).unwrap();
    let mut video_input = format::input(&video.to_string()).unwrap();
    let mut merge_output = format::output(&merge).unwrap();
    transcoder(&mut audio_input, &mut video_input, &mut merge_output, &merge.to_string());
}

fn transcoder<P: AsRef<Path>>(
    audio_input: &mut format::context::Input,
    video_input: &mut format::context::Input,
    merge_output: &mut format::context::Output,
    path: &P,
) -> Result<Transcoder> {

    // audio
    let audio_input = audio_input
        .streams()
        .best(media::Type::Audio)
        .context("could not find best audio stream")?;

    let mut audio_input_context = ffmpeg::codec::context::Context::new();
    audio_input_context.set_parameters(audio_input.parameters())?;
    let mut audio_decoder = audio_input_context.decoder().audio()?;
    let audio_codec = ffmpeg::encoder::find(merge_output.format().codec(path, media::Type::Audio))
        .expect("failed to find encoder")
        .audio()?;

    // video
    let video_input = video_input
        .streams()
        .best(media::Type::Video)
        .context("could not find best video stream")?;
    let mut video_input_context = ffmpeg::codec::context::Context::new();
    video_input_context.set_parameters(video_input.parameters())?;
    let mut video_decoder = video_input_context.decoder().audio()?;
    let video_codec = ffmpeg::encoder::find(merge_output.format().codec(path, media::Type::Video))
        .expect("failed to find encoder")
        .video()?;

    // out
    let global = merge_output
        .format()
        .flags()
        .contains(ffmpeg::format::flag::Flags::GLOBAL_HEADER);


    // audio
    let mut audio_output = merge_output.add_stream(audio_codec)?;
    let mut audio_output_context = ffmpeg::codec::context::Context::new();
    audio_output_context.set_parameters(audio_output.parameters())?;
    let mut audio_encoder = audio_output_context.encoder().audio()?;

    // video
    let mut video_output = merge_output.add_stream(video_codec)?;
    let mut video_output_context = ffmpeg::codec::context::Context::new();
    video_output_context.set_parameters(video_output.parameters())?;
    let mut video_encoder = video_output_context.encoder().video()?;

    //

    let audio_channel_layout = audio_codec
        .channel_layouts()
        .map(|cls| cls.best(audio_encoder.channel_layout().channels()))
        .unwrap_or(ffmpeg::channel_layout::ChannelLayout::STEREO);

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


    audio_encoder.set_rate(audio_decoder.rate() as i32);
    audio_encoder.set_channel_layout(audio_channel_layout);
    audio_encoder.set_channels(audio_channel_layout.channels());
    audio_encoder.set_format(
        codec
            .formats()
            .expect("unknown supported formats")
            .next()
            .unwrap(),
    );
    audio_encoder.set_bit_rate(audio_decoder.bit_rate());
    audio_encoder.set_max_bit_rate(audio_decoder.max_bit_rate());

    audio_encoder.set_time_base((1, audio_decoder.rate() as i32));
    output.set_time_base((1, audio_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 {})
}

struct Transcoder {}

[thewh1teagle]

Hey!
Did you found solution?
Thanks

[niuhuan]

Search 'ffmpeg_merge_file' at https://github.com/niuhuan/bili-cli-rs/blob/master/src/ffmpeg.rs