[nihav-encoder.git] / src / main.rs

extern crate nihav_core;
extern crate nihav_codec_support;
extern crate nihav_registry;
extern crate nihav_allstuff;

use std::fs::File;
use std::io::Write;
use nihav_core::frame::*;
use nihav_core::options::*;
use nihav_core::codecs::*;
use nihav_core::demuxers::*;
use nihav_core::muxers::*;
use nihav_core::reorder::*;
use nihav_registry::detect;
use nihav_registry::register;
use std::env;
use std::time::{Duration, Instant};

macro_rules! parse_and_apply_options {
    ($obj: expr, $in_opts: expr, $name: expr) => {
        let mut opts = Vec::with_capacity($in_opts.len());
        let opt_def = $obj.get_supported_options();
        for opt in $in_opts.iter() {
            let mut found = false;
            for opt_def in opt_def.iter() {
                let mut matches = opt.name == opt_def.name;
                if !matches && opt.name.starts_with("no") {
                    let (_, name) = opt.name.split_at(2);
                    matches = name == opt_def.name;
                }
                if matches {
                    let arg = if let Some(ref strval) = opt.value { Some(strval) } else { None };
                    let ret = opt_def.parse(&opt.name, arg);
                    if let Ok((val, _)) = ret {
                        opts.push(val);
                    } else {
                        println!("invalid option {} for {}", opt.name, $name);
                    }
                    found = true;
                }
            }
            if !found {
                println!("  ignoring option '{}' for {}", opt.name, $name);
            }
        }
        $obj.set_options(opts.as_slice());
    }
}

mod demux;
use crate::demux::FullRegister;
mod null;
mod acvt;
mod imgseq;
mod transcoder;
use crate::transcoder::*;


fn format_time(ms: u64) -> String {
    let s = ms / 1000;
    let ds = (ms % 1000) / 100;
    let (min, s) = (s / 60, s % 60);
    let (h, min) = (min / 60, min % 60);
    if h == 0 {
        if min == 0 {
            format!("{}.{}", s, ds)
        } else {
            format!("{}:{:02}.{}", min, s, ds)
        }
    } else {
        format!("{}:{:02}:{:02}.{}", h, min, s, ds)
    }
}

fn print_options(name: &str, options: &[NAOptionDefinition]) {
    if options.is_empty() {
        println!("No custom options.");
    } else {
        println!("Options for '{}'", name);
        for opt in options.iter() {
            println!(" {}", opt);
        }
    }
}

macro_rules! next_arg {
    ($args: expr, $arg_idx: expr) => {
        if $arg_idx + 1 >= $args.len() {
            println!("codec name is required");
        }
        $arg_idx += 1;
    }
}

macro_rules! parse_id {
    ($val: expr, $stype: expr, $maxval: expr) => {
        if $val.is_empty() {
            0
        } else if let Ok(val) = $val.parse::<usize>() {
            if val < $maxval {
                val
            } else {
                println!("{} number should be below {}", $stype, $maxval);
                return;
            }
        } else {
            println!("invalid {} number '{}'", $stype, $val);
            return;
        }
    }
}

fn retrieve_packets(transcoder: &mut Transcoder, mux: &mut Muxer, vdata_size: &mut usize, adata_size: &mut usize, end: bool) -> bool {
    while let Some(pkt) = transcoder.queue.get_packet() {
        if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) {
            return false;
        }
        let pkt_size = pkt.get_buffer().len();
        match pkt.get_stream().get_media_type() {
            StreamType::Video => { *vdata_size += pkt_size; },
            StreamType::Audio => { *adata_size += pkt_size; },
            _ => {},
        };
        if mux.mux_frame(pkt).is_err() {
            println!("error muxing packet");
            return false;
        }
    }
    if end {
        while let Some(pkt) = transcoder.queue.get_last_packet() {
            if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) {
                return false;
            }
            let pkt_size = pkt.get_buffer().len();
            match pkt.get_stream().get_media_type() {
                StreamType::Video => { *vdata_size += pkt_size; },
                StreamType::Audio => { *adata_size += pkt_size; },
                _ => {},
            };
            if mux.mux_frame(pkt).is_err() {
                println!("error muxing packet");
                return false;
            }
        }
    }
    true
}

#[allow(clippy::single_match)]
fn main() {
    let args: Vec<_> = env::args().collect();

    if args.len() == 1 {
        println!("usage: nihav-encoder [options] --input inputfile --output outputfile");
        println!(" use nihav-encoder --help to list all available options");
        return;
    }
    if args.len() == 2 && (args[1] == "--help" || args[1] == "-h") {
        println!("usage: nihav-encoder [options] --input inputfile --output outputfile");
        println!(" query options:");
        println!("  --list-{{decoders,encoders,demuxers,muxers}} - lists all available decoders/encoders/demuxers/muxers");
        println!("  --query-{{decoder,encoder,demuxer,muxer}}-options name - lists all options recognized by that decoder/encoder/demuxer/muxer");
        println!(" processing options:");
        println!("  --verbose                   - show time for the currently processed input");
        println!("  --input inputfile           - set input file");
        println!("  --input-format fmt          - force input format");
        println!("  --demuxer-options options   - set input demuxer options");
        println!("  --scale-options options     - set scaler options");
        println!("  --output outputfile         - set output file");
        println!("  --output-format fmt         - force output format");
        println!("  --muxer-options options     - set output muxer options");
        println!("  --no-audio                  - do not decode audio streams");
        println!("  --no-video                  - do not decode video streams");
        println!("  --start starttime           - start decoding from given position");
        println!("  --end endtime               - end decoding at given position");
        println!("  --istreamX options          - set options for input stream X");
        println!("  --ostreamX options          - set options for output stream X");
        println!();
        println!(" (de)muxer and stream options are passed as comma-separated list e.g. --ostream0 width=320,height=240,flip");
        return;
    }

    let full_reg = FullRegister::new();

    let mut transcoder = Transcoder::new();

    let mut arg_idx = 1;
    let mut printed_info = false;
    let mut force_sync = false;
    let mut profile_name = "".to_string();
    let mut custom_profile = false;
    while arg_idx < args.len() {
        match args[arg_idx].as_str() {
            "--list-decoders" => {
                if full_reg.dec_reg.iter().len() > 0 {
                    println!("Registered decoders:");
                    for dec in full_reg.dec_reg.iter() {
                        let cdesc = register::get_codec_description(dec.name);
                        let full_name = if let Some(cd) = cdesc { cd.get_full_name() } else { "???" };
                        println!(" {} ({})", dec.name, full_name);
                    }
                } else {
                    println!("No registered decoders.");
                }
                printed_info = true;
            },
            "--list-encoders" => {
                if full_reg.enc_reg.iter().len() > 0 {
                    println!("Registered encoders:");
                    for enc in full_reg.enc_reg.iter() {
                        let cdesc = register::get_codec_description(enc.name);
                        let full_name = if let Some(cd) = cdesc { cd.get_full_name() } else { "???" };
                        println!(" {} ({})", enc.name, full_name);
                    }
                } else {
                    println!("No registered encoders.");
                }
                printed_info = true;
            },
            "--list-demuxers" => {
                print!("Registered demuxers:");
                for dmx in full_reg.dmx_reg.iter() {
                    print!(" {}", dmx.get_name());
                }
                println!();
                printed_info = true;
            },
            "--list-muxers" => {
                print!("Registered muxers:");
                for mux in full_reg.mux_reg.iter() {
                    print!(" {}", mux.get_name());
                }
                println!();
                printed_info = true;
            },
            "--query-decoder-options" => {
                next_arg!(args, arg_idx);
                let cname = args[arg_idx].as_str();
                if let Some(decfunc) = full_reg.dec_reg.find_decoder(cname) {
                    let dec = (decfunc)();
                    let opts = dec.get_supported_options();
                    print_options(cname, opts);
                } else {
                    println!("codec {} is not found", cname);
                }
                printed_info = true;
            },
            "--query-demuxer-options" => {
                next_arg!(args, arg_idx);
                let dname = args[arg_idx].as_str();
                let mut mr = MemoryReader::new_read(&[]);
                let mut br = ByteReader::new(&mut mr);
                if let Some(dmx_creator) = full_reg.dmx_reg.find_demuxer(dname) {
                    let dmx = dmx_creator.new_demuxer(&mut br);
                    let opts = dmx.get_supported_options();
                    print_options(dname, opts);
                } else {
                    println!("demuxer {} is not found", dname);
                }
                printed_info = true;
            },
            "--query-encoder-options" => {
                next_arg!(args, arg_idx);
                let cname = args[arg_idx].as_str();
                if let Some(encfunc) = full_reg.enc_reg.find_encoder(cname) {
                    let enc = (encfunc)();
                    let opts = enc.get_supported_options();
                    print_options(cname, opts);
                } else {
                    println!("codec {} is not found", cname);
                }
                printed_info = true;
            },
            "--query-muxer-options" => {
                next_arg!(args, arg_idx);
                let name = args[arg_idx].as_str();
                let mut data = [];
                let mut mw = MemoryWriter::new_write(&mut data);
                let mut bw = ByteWriter::new(&mut mw);
                if let Some(mux_creator) = full_reg.mux_reg.find_muxer(name) {
                    let mux = mux_creator.new_muxer(&mut bw);
                    let opts = mux.get_supported_options();
                    print_options(name, opts);
                } else {
                    println!("muxer {} is not found", name);
                }
                printed_info = true;
            },
            "--output" | "-o" => {
                next_arg!(args, arg_idx);
                transcoder.output_name = args[arg_idx].clone();
            },
            "--output-format" => {
                next_arg!(args, arg_idx);
                transcoder.output_fmt = Some(args[arg_idx].clone());
            },
            "--scale-options" => {
                next_arg!(args, arg_idx);
                if !transcoder.parse_scale_options(&args[arg_idx]) {
                    println!("invalid scale option syntax");
                    return;
                }
            },
            "--no-video" | "-vn" => {
                transcoder.no_video = true;
            },
            "--no-audio" | "-an" => {
                transcoder.no_audio = true;
            },
            "--start" => {
                next_arg!(args, arg_idx);
                let ret = args[arg_idx].parse::<NATimePoint>();
                if let Ok(val) = ret {
                    transcoder.start = val;
                } else {
                    println!("invalid start time");
                    return;
                }
            },
            "--end" => {
                next_arg!(args, arg_idx);
                let ret = args[arg_idx].parse::<NATimePoint>();
                if let Ok(val) = ret {
                    transcoder.end = val;
                } else {
                    println!("invalid end time");
                    return;
                }
            },
            "--sync" => {
                force_sync = true;
            },
            "--muxer-options" => {
                next_arg!(args, arg_idx);
                if !transcoder.parse_muxer_options(&args[arg_idx], &full_reg.mux_reg) {
                    println!("invalid muxer option syntax");
                    return;
                }
            },
            "--calc-len" => {
                transcoder.calc_len = true;
            },
            "--print-profiles" => {
                println!("Supported profiles:");
                for (name, profiles) in PROFILES.iter() {
                    print!("  profiles for format '{name}': ");
                    for profile in profiles.iter() {
                        print!(" {}", profile.name);
                    }
                    println!();
                }
                printed_info = true;
            },
            "--profile" => {
                next_arg!(args, arg_idx);
                profile_name = args[arg_idx].to_string();
            },
            "--verbose" | "-v" => transcoder.verbose = 1,
            "-vv" => transcoder.verbose = 2,
            "-v-" => transcoder.verbose = 0,
            _ => {
                if args[arg_idx].starts_with("--istream") {
                    let opt0 = &args[arg_idx];
                    next_arg!(args, arg_idx);
                    if !transcoder.parse_istream_options(opt0, &args[arg_idx]) {
                        println!("invalid input stream option syntax");
                        return;
                    }
                } else if args[arg_idx].starts_with("--ostream") {
                    let opt0 = &args[arg_idx];
                    next_arg!(args, arg_idx);
                    if !transcoder.parse_ostream_options(opt0, &args[arg_idx], &full_reg.enc_reg) {
                        println!("invalid output stream option syntax");
                        return;
                    }
                    custom_profile = true;
                } else if args[arg_idx].starts_with("--iformat") {
                    let id = parse_id!(&args[arg_idx][9..], "input format", transcoder.input_fmt.len());
                    next_arg!(args, arg_idx);
                    transcoder.input_fmt[id] = Some(args[arg_idx].clone());
                } else if args[arg_idx].starts_with("--input-format") {
                    let id = parse_id!(&args[arg_idx][14..], "input format", transcoder.input_fmt.len());
                    next_arg!(args, arg_idx);
                    transcoder.input_fmt[id] = Some(args[arg_idx].clone());
                } else if args[arg_idx].starts_with("--input") { // should be after --input-format
                    let id = parse_id!(&args[arg_idx][7..], "input", transcoder.input_name.len());
                    next_arg!(args, arg_idx);
                    transcoder.input_name[id] = Some(args[arg_idx].clone());
                } else if args[arg_idx].starts_with("-i") {
                    let id = parse_id!(&args[arg_idx][2..], "input", transcoder.input_name.len());
                    next_arg!(args, arg_idx);
                    transcoder.input_name[id] = Some(args[arg_idx].clone());
                } else if args[arg_idx].starts_with("--demuxer-options") {
                    let id = parse_id!(&args[arg_idx][17..], "input options", transcoder.demux_opts.len());
                    next_arg!(args, arg_idx);
                    if !transcoder.parse_demuxer_options(&args[arg_idx], &full_reg.dmx_reg, id) {
                        println!("invalid demuxer option syntax");
                        return;
                    }
                } else if args[arg_idx].starts_with("--") {
                    println!("unknown option '{}'", args[arg_idx]);
                } else {
                    println!("unrecognized argument '{}'", args[arg_idx]);
                }
            },
        };
        arg_idx += 1;
    }

    if printed_info {
        return;
    }

    if transcoder.input_name.iter().flatten().count() == 0 {
        println!("no input name(s) provided");
        return;
    }
    if transcoder.output_name.is_empty() {
        println!("no output name provided");
        return;
    }

    let mut demuxers = Vec::with_capacity(1);
    if !transcoder.create_demuxers(&mut demuxers, &full_reg, true) {
        return;
    }

    let duration = demuxers.iter().fold(0u64, |mindur, (dmx, _)| {
            let dur = dmx.get_duration();
            if mindur == 0 {
                dur
            } else if dur > 0 {
                mindur.min(dur)
            } else {
                mindur
            }
        });
    let duration_string = if duration != 0 { format_time(duration) } else { String::new() };

    let mut ism = StreamManager::new();
    let mut is_offset = Vec::with_capacity(demuxers.len());
    let mut start = 0;
    let mut nstreams = 0;
    for (dmx, _) in demuxers.iter() {
        is_offset.push(nstreams);
        let sm = dmx.get_stream_manager();
        let max_id = sm.iter().fold(0u32, |id, strm| id.max(strm.id));
        for stream in sm.iter() {
            let mut newstream = (*stream).clone();
            if transcoder.global_tb == (0, 0) && newstream.get_media_type() == StreamType::Video {
                transcoder.global_tb = newstream.get_timebase();
            }
            newstream.id += start;
            ism.add_stream(newstream);
        }
        start += max_id + 1;
        nstreams += sm.get_num_streams();
    }

    for (&is_off, (dmx, _)) in is_offset.iter().zip(demuxers.iter_mut()) {
        for i in 0..dmx.get_num_streams() {
            let s = dmx.get_stream(i).unwrap();
            let info = s.get_info();
            let decfunc = full_reg.dec_reg.find_decoder(info.get_name());
            let str_id = (s.get_num() + is_off) as u32;
            if let Some(create_dec) = decfunc {
                let mut decoder = (create_dec)();
                let mut dsupp = Box::new(NADecoderSupport::new());
                let ret = decoder.init(&mut dsupp, info.clone());
                if ret.is_err() {
                    println!("Error initialising decoder '{}' for stream {}", info.get_name(), str_id);
                    return;
                }
                transcoder.apply_decoder_options(decoder.as_mut(), str_id);
                let desc = register::get_codec_description(info.get_name());
                let has_b = if let Some(desc) = desc {
                        desc.has_reorder()
                    } else {
                        println!("No codec description found, using B-frame reorderer.");
                        true
                    };
                let reorderer: Box<dyn FrameReorderer> = if has_b { Box::new(IPBReorderer::new()) } else { Box::new(NoReorderer::new()) };
                transcoder.decoders.push(Some(DecodeContext{ dsupp, decoder, reorderer }));
            } else {
                println!("No decoder for stream {} ({}) is found", str_id, info.get_name());
                transcoder.decoders.push(None);
            }
        }
        if transcoder.start != NATimePoint::None {
            let ret = dmx.seek(transcoder.start);
            if ret.is_err() {
                println!(" failed to seek to {} error {:?}", transcoder.start, ret.err().unwrap());
            }
        }
    }

    let output_fmt = if let Some(ref fmtname) = transcoder.output_fmt {
            fmtname
        } else if transcoder.output_name.as_str() == "/dev/null" {
            "null"
        } else if let Some(fmtname) = detect::detect_format_by_name(transcoder.output_name.as_str()) {
            fmtname
        } else {
            println!("Cannot guess muxer for output");
            return;
        };
    let ret = full_reg.mux_reg.find_muxer(output_fmt);
    let ofmt = output_fmt.to_string();

    if ret.is_none() {
        println!("cannot find muxer '{}'", output_fmt);
        return;
    }
    let mux_creator = ret.unwrap();

    if custom_profile && !profile_name.is_empty() {
        println!("profile setting is incompatible with custom --ostream options");
        return;
    }
    if !profile_name.is_empty() {
        if let Some(profiles) = PROFILES.iter().find(|(fmt, _)| fmt == &output_fmt) {
            if let Some(ref_profile) = profiles.1.iter().find(|p| p.name == profile_name) {
                transcoder.profile = Some(ref_profile.profile);
            } else {
                println!("profile '{profile_name}' is not defined for output format '{output_fmt}'");
            }
        } else {
            println!("no profiles for output format '{output_fmt}'");
        }
    }

    let mux_quirks = mux_creator.get_quirks();
    if mux_quirks.is_fixed_duration() {
        transcoder.calc_len = true;
    }
    transcoder.fixed_rate = mux_quirks.is_fixed_rate();
    transcoder.queue.set_sync(force_sync || !mux_quirks.is_unsync());

    if transcoder.calc_len {
        let mut sids = Vec::new();
        transcoder.nframes.clear();
        for (dmx, _) in demuxers.iter_mut() {
            let sstart = transcoder.nframes.len();
            let sm = dmx.get_stream_manager();
            sids.clear();
            for stream in sm.iter() {
                transcoder.nframes.push(0);
                sids.push(stream.get_id());
            }

            while let Ok(pkt) = dmx.get_frame() {
                let stream = pkt.get_stream();
                let pos = sstart + sids.iter().position(|&x| x == stream.get_id()).unwrap();
                transcoder.nframes[pos] += 1;
            }
        }
        // this is necessary since not all demuxers allow to seek even back to the start
        demuxers.clear();
        if !transcoder.create_demuxers(&mut demuxers, &full_reg, false) {
            println!("failed to re-create demuxer(s)");
            return;
        }
    }

    let mux_caps = mux_creator.get_capabilities();
    let mut out_sm = StreamManager::new();
    if !transcoder.negotiate_stream_map(&ism, mux_caps, &mut out_sm, &full_reg.enc_reg) {
        println!("cannot determine stream map");
        return;
    }

    let ret = File::create(transcoder.output_name.as_str());
    if ret.is_err() {
        println!("cannot open output file");
        return;
    }
    let mut fw = FileWriter::new_write(ret.unwrap());
    let mut bw = ByteWriter::new(&mut fw);
    let ret = create_muxer(mux_creator, out_sm, &mut bw);
    if let Err(err) = ret {
        println!("cannot create muxer instance {:?}", err);
        return;
    }
    let mut mux = ret.unwrap();
    parse_and_apply_options!(mux, &transcoder.mux_opts, "output");

    println!("Output {} muxer {}", transcoder.output_name, ofmt);
    for ostr in mux.get_streams() {
        let mut is_copy = false;
        let stream_id = ostr.get_num() as u32;
        for omode in transcoder.encoders.iter() {
            if let OutputMode::Copy(sno) = omode {
                if sno == &stream_id {
                    is_copy = true;
                    break;
                }
            }
        }
        println!(" #{}: {} {}{}", ostr.get_num(), ostr, ostr.get_info().get_name(), if is_copy { " (copy)" } else { "" });
    }

    transcoder.queue.reserve_streams(mux.get_num_streams());

    let mut time = Instant::now();
    let show_interval = Duration::from_millis(100);
    let mut adata_size = 0;
    let mut vdata_size = 0;
    let mut cur_dmx = 0;
    let mut last_known_time = None;
    'main_loop: loop {
        let mut pktres = Err(DemuxerError::EOF);
        let mut src_dmx = 0;
        loop {
            if !demuxers.iter().any(|(_, eof)| !eof) {
                break;
            }
            let mut got_res = false;
            if !demuxers[cur_dmx].1 {
                pktres = demuxers[cur_dmx].0.get_frame();
                got_res = true;
                src_dmx = cur_dmx;
            }
            cur_dmx += 1;
            if cur_dmx >= demuxers.len() {
                cur_dmx = 0;
            }
            if got_res {
                break;
            }
        }

        if let Err(DemuxerError::EOF) = pktres { break; }
        if pktres.is_err() {
            println!("demuxing error");
            break;
        }
        let mut pkt = pktres.unwrap();
        if transcoder.start != NATimePoint::None && pkt.ts.less_than(transcoder.start) { continue; }
        let src_id = pkt.get_stream().get_num() + is_offset[src_dmx];
        let ts = pkt.ts;
        let newstream = ism.get_stream(src_id).unwrap();
        pkt.reassign(newstream, ts);

        if transcoder.verbose > 0 && time.elapsed() >= show_interval {
            if let Some(pts) = pkt.get_pts() {
                 let cur_time = format_time(NATimeInfo::ts_to_time(pts, 1000, pkt.ts.tb_num, pkt.ts.tb_den));
                print!(" {}", cur_time);
                last_known_time = Some(cur_time);
            } else if let Some(ref time) = last_known_time {
                print!(" {time}");
            } else {
                print!(" ???");
            }
            if !duration_string.is_empty() {
                print!(" / {}", duration_string);
            }
            if transcoder.verbose > 1 {
                print!(" data sizes V: {} A: {}", vdata_size, adata_size);
            }
            print!("\r");
            std::io::stdout().flush().unwrap();
            time = Instant::now();
        }
        match transcoder.encoders[src_id] {
            OutputMode::Drop => {},
            OutputMode::Copy(dst_id) => {
                let dstr = mux.get_stream(dst_id as usize).unwrap();
                pkt.reassign(dstr, pkt.get_time_information());
                if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'main_loop; }
                let pkt_size = pkt.get_buffer().len();
                match pkt.get_stream().get_media_type() {
                    StreamType::Video => { vdata_size += pkt_size; },
                    StreamType::Audio => { adata_size += pkt_size; },
                    _ => {},
                };
                transcoder.queue.queue_packet(pkt);
            },
            OutputMode::Encode(dst_id, ref mut encoder) => {
                if let Some(ref mut dec_ctx) = transcoder.decoders[src_id] {
                    let ret = dec_ctx.decoder.decode(&mut dec_ctx.dsupp, &pkt);
                    if let (true, Err(DecoderError::MissingReference)) = (transcoder.start != NATimePoint::None, &ret) {
                        continue;
                    }
                    if ret.is_err() {
                        println!("error decoding stream {}", src_id);
                        break;
                    }
                    let frm = ret.unwrap();
                    dec_ctx.reorderer.add_frame(frm);
                    while let Some(frm) = dec_ctx.reorderer.get_frame() {
                        match encoder.encode_frame(dst_id, frm, &transcoder.scale_opts, &mut transcoder.queue) {
                            Ok(true) => {},
                            Ok(false) => break,
                            Err(err) => {
                                println!("encoder error {err:?}");
                                break 'main_loop;
                            }
                        }
                    }
                } else {
                    println!("no decoder for stream {}", src_id);
                    break;
                }
            },
        };

        if !retrieve_packets(&mut transcoder, &mut mux, &mut vdata_size, &mut adata_size, false) {
            break;
        }
    }
    'reord_flush_loop: for stream in ism.iter() {
        let src_id = stream.get_num();
        if let OutputMode::Encode(dst_id, ref mut encoder) = transcoder.encoders[src_id] {
            if let Some(ref mut dec_ctx) = transcoder.decoders[src_id] {
                while let Some(frm) = dec_ctx.reorderer.get_last_frames() {
                    match encoder.encode_frame(dst_id, frm, &transcoder.scale_opts, &mut transcoder.queue) {
                        Ok(true) => {},
                        Ok(false) => break,
                        Err(err) => {
                            println!("encoder error {err:?}");
                            break 'reord_flush_loop;
                        }
                    }
                }
            }
        }
    }
    /*'flush_loop:*/ for enc in transcoder.encoders.iter_mut() {
        match enc {
            OutputMode::Encode(str_id, ref mut encoder) => {
                let ret = encoder.flush(&mut transcoder.queue);
                if ret.is_err() {
                    println!("error flushing encoder for stream {}", str_id);
                    break;
                }
            },
            _ => {},
        };
    }

    retrieve_packets(&mut transcoder, &mut mux, &mut vdata_size, &mut adata_size, true);

    if transcoder.verbose > 0 {
        println!();
    }

    let ret = mux.end();
    if ret.is_err() {
        println!("error at finalising muxing");
    }
}

struct ProfileDef {
    name:    &'static str,
    profile: EncodingProfile,
}

const PROFILES: &[(&str, &[ProfileDef])] = &[
    ("avi",
    &[
        ProfileDef {
            name:       "cinepak",
            profile:    EncodingProfile {
                vname:      "cinepak",
                voptions:   &[],
                aname:      "pcm",
                aoptions:   &[],
            }
        },
        ProfileDef {
            name:       "lossless",
            profile:    EncodingProfile {
                vname:      "zmbv",
                voptions:   &[("range", Some("4")), ("compr_level", Some("fast"))],
                aname:      "pcm",
                aoptions:   &[],
            }
        },
        ProfileDef {
            name:       "ms-lossy",
            profile:    EncodingProfile {
                vname:      "msvideo1",
                voptions:   &[],
                aname:      "ms-adpcm",
                aoptions:   &[],
            }
        },
         ProfileDef {
            name:       "raw",
            profile:    EncodingProfile {
                vname:      "rawvideo-ms",
                voptions:   &[],
                aname:      "pcm",
                aoptions:   &[],
            }
        },
    ]),
];