feat(tests): enhance ffmpeg examples with improved channel layout handling and logging

ldm0 · ldm0 · commit 06f6695989e5 · 2025-08-24T05:07:11.000+08:00
diff --git a/tests/ffmpeg_examples/demux_decode.rs b/tests/ffmpeg_examples/demux_decode.rs
@@ -8,7 +8,7 @@ use rsmpeg::{
         get_sample_fmt_name, sample_fmt_is_planar, ts2timestr, AVChannelLayout, AVFrame,
     },
     error::RsmpegError,
-    ffi,
+    ffi::{self, AV_CHANNEL_LAYOUT_MONO},
 };
 use std::{ffi::CStr, fs, io::Write, path::Path};
 
@@ -300,7 +300,7 @@ fn demux_decode(input_raw: &CStr, video_out: &str, audio_out: &str) -> Result<()
                 planar_name
             );
             sfmt = get_packed_sample_fmt(sfmt).context("Cannot get packed sample fmt")?;
-            ch_layout = AVChannelLayout::from_nb_channels(1);
+            ch_layout = unsafe { AVChannelLayout::new(AV_CHANNEL_LAYOUT_MONO) };
         }
         let fmt = get_format_from_sample_fmt(sfmt).ok_or_else(|| {
             let name = get_sample_fmt_name(sfmt)
diff --git a/tests/ffmpeg_examples/encode_video.rs b/tests/ffmpeg_examples/encode_video.rs
@@ -20,13 +20,18 @@ fn encode(
     frame: Option<&AVFrame>,
     file: &mut BufWriter<File>,
 ) -> Result<()> {
+    if let Some(frame) = frame {
+        println!("Send frame {:3}", frame.pts);
+    }
+
     encode_context.send_frame(frame)?;
     loop {
         let packet = match encode_context.receive_packet() {
             Ok(packet) => packet,
             Err(RsmpegError::EncoderDrainError) | Err(RsmpegError::EncoderFlushedError) => break,
             Err(e) => return Err(e.into()),
         };
+        println!("Write packet {:3} (size={:5})", packet.pts, packet.size);
         let data = unsafe { std::slice::from_raw_parts(packet.data, packet.size as usize) };
         file.write_all(data)?;
     }
diff --git a/tests/ffmpeg_examples/filter_audio.rs b/tests/ffmpeg_examples/filter_audio.rs
@@ -3,11 +3,12 @@ use anyhow::{Context, Result};
 use rsmpeg::{
     avfilter::{AVFilter, AVFilterGraph},
     avutil::{
-        get_bytes_per_sample, get_sample_fmt_name, sample_fmt_is_planar, AVChannelLayout,
+        get_bytes_per_sample, get_sample_fmt_name, sample_fmt_is_planar, AVChannelLayoutRef,
         AVDictionary, AVFrame, AVMD5,
     },
-    ffi,
+    ffi::{self, AV_CHANNEL_LAYOUT_5POINT0},
 };
+use std::f32::consts::PI;
 
 const INPUT_SAMPLERATE: i32 = 48_000;
 const FRAME_SIZE: i32 = 1024;
@@ -20,7 +21,7 @@ fn init_filter_graph() -> Result<AVFilterGraph> {
     let aformat = AVFilter::get_by_name(c"aformat").context("aformat not found")?;
 
     // abuffer options via AVOptions, like the C example
-    let ch_layout = AVChannelLayout::from_nb_channels(5).describe()?;
+    let ch_layout = unsafe { AVChannelLayoutRef::new(&AV_CHANNEL_LAYOUT_5POINT0) }.describe()?;
     let sample_fmt = get_sample_fmt_name(ffi::AV_SAMPLE_FMT_FLTP).unwrap_or(c"fltp");
 
     // Create abuffer as "src"
@@ -119,26 +120,28 @@ fn process_output(md5: &mut AVMD5, frame: &AVFrame) -> Result<()> {
 }
 
 fn get_input(frame_num: i64) -> Result<AVFrame> {
-    let mut f = AVFrame::new();
-    f.set_sample_rate(INPUT_SAMPLERATE);
-    f.set_format(ffi::AV_SAMPLE_FMT_FLTP);
-    f.set_ch_layout(rsmpeg::avutil::AVChannelLayout::from_nb_channels(5).into_inner());
-    f.set_nb_samples(FRAME_SIZE);
-    f.set_pts(frame_num * FRAME_SIZE as i64);
-    f.get_buffer(0)?;
+    // Replicate C example: FRAME_SIZE samples, 5 channels (5.0 layout), FLTP
+    let mut frame = AVFrame::new();
+    frame.set_sample_rate(INPUT_SAMPLERATE);
+    frame.set_format(ffi::AV_SAMPLE_FMT_FLTP);
+    // Use exact 5.0 channel layout constant instead of default-from-count
+    frame.set_ch_layout(AV_CHANNEL_LAYOUT_5POINT0);
+    frame.set_nb_samples(FRAME_SIZE);
+    frame.set_pts(frame_num * FRAME_SIZE as i64);
+    frame.get_buffer(0)?;
 
-    // fill planar float samples: 5 channels
+    // Fill each planar channel with: sin(2 * PI * (frame_num + sample_index) * (channel+1) / FRAME_SIZE)
     unsafe {
         for ch in 0..5 {
-            let ptr = f.data[ch] as *mut f32;
-            for i in 0..FRAME_SIZE as isize {
-                let val =
-                    ((frame_num as f32 + i as f32) * (ch as f32 + 1.0) / FRAME_SIZE as f32).sin();
-                *ptr.offset(i) = val;
+            let base = frame.data[ch] as *mut f32;
+            for j in 0..FRAME_SIZE as isize {
+                let phase = 2.0 * PI * (frame_num as f32 + j as f32) * (ch as f32 + 1.0)
+                    / FRAME_SIZE as f32;
+                *base.offset(j) = phase.sin();
             }
         }
     }
-    Ok(f)
+    Ok(frame)
 }
 
 pub fn filter_audio_process(duration: f32) -> Result<usize> {
diff --git a/tests/ffmpeg_examples/resample_audio.rs b/tests/ffmpeg_examples/resample_audio.rs
@@ -1,10 +1,33 @@
 //! RIIR: https://github.com/FFmpeg/FFmpeg/blob/master/doc/examples/resample_audio.c
 use rsmpeg::{
-    avutil::{AVChannelLayout, AVFrame},
-    ffi,
+    avutil::{av_rescale_rnd, get_bytes_per_sample, AVChannelLayout, AVSamples},
+    ffi::{self, AV_CHANNEL_LAYOUT_STEREO, AV_CHANNEL_LAYOUT_SURROUND},
     swresample::SwrContext,
 };
-use std::io::Write;
+use std::{f64::consts::PI, io::Write};
+
+fn get_format_from_sample_fmt(sample_fmt: ffi::AVSampleFormat) -> Option<&'static str> {
+    #[cfg(target_endian = "big")]
+    let sample_fmt_entries = [
+        (ffi::AV_SAMPLE_FMT_U8, "u8"),
+        (ffi::AV_SAMPLE_FMT_S16, "s16be"),
+        (ffi::AV_SAMPLE_FMT_S32, "s32be"),
+        (ffi::AV_SAMPLE_FMT_FLT, "f32be"),
+        (ffi::AV_SAMPLE_FMT_DBL, "f64be"),
+    ];
+    #[cfg(target_endian = "little")]
+    let sample_fmt_entries = [
+        (ffi::AV_SAMPLE_FMT_U8, "u8"),
+        (ffi::AV_SAMPLE_FMT_S16, "s16le"),
+        (ffi::AV_SAMPLE_FMT_S32, "s32le"),
+        (ffi::AV_SAMPLE_FMT_FLT, "f32le"),
+        (ffi::AV_SAMPLE_FMT_DBL, "f64le"),
+    ];
+    sample_fmt_entries
+        .iter()
+        .find(|(fmt, _)| *fmt == sample_fmt)
+        .map(|(_, fmt)| *fmt)
+}
 
 fn fill_samples(
     buf: &mut [f64],
@@ -14,7 +37,7 @@ fn fill_samples(
     t: &mut f64,
 ) {
     let tincr = 1.0 / sample_rate as f64;
-    let c = 2.0 * std::f64::consts::PI * 440.0;
+    let c = 2.0 * PI * 440.0;
     let mut dstp = buf.as_mut_ptr();
     for _ in 0..nb_samples {
         unsafe {
@@ -29,52 +52,118 @@ fn fill_samples(
 }
 
 pub fn resample_audio_run(out_path: &str) -> anyhow::Result<usize> {
-    // src: stereo dbl 48k, dst: 5.1 s16 44.1k
-    let src_ch = AVChannelLayout::from_nb_channels(2);
-    let dst_ch = AVChannelLayout::from_nb_channels(6);
+    // Match C example: src=stereo 48kHz DBL, dst=surround 44.1kHz S16
+    let src_ch_layout = unsafe { AVChannelLayout::new(AV_CHANNEL_LAYOUT_STEREO) }; // stereo
+    let dst_ch_layout = unsafe { AVChannelLayout::new(AV_CHANNEL_LAYOUT_SURROUND) }; // surround
+    let src_rate = 48000;
+    let dst_rate = 44100;
+    let src_sample_fmt = ffi::AV_SAMPLE_FMT_DBL;
+    let dst_sample_fmt = ffi::AV_SAMPLE_FMT_S16;
+    let src_nb_samples = 1024;
+    let src_nb_channels = src_ch_layout.nb_channels;
+    let dst_nb_channels = dst_ch_layout.nb_channels;
+
     let mut swr = SwrContext::new(
-        &dst_ch.into_inner(),
-        ffi::AV_SAMPLE_FMT_S16,
-        44100,
-        &src_ch.into_inner(),
-        ffi::AV_SAMPLE_FMT_DBL,
-        48000,
+        &dst_ch_layout,
+        dst_sample_fmt,
+        dst_rate,
+        &src_ch_layout,
+        src_sample_fmt,
+        src_rate,
     )
     .unwrap();
     swr.init().unwrap();
 
-    // build src frame
-    let nb = 1024;
-    let mut src = AVFrame::new();
-    src.set_nb_samples(nb);
-    src.set_format(ffi::AV_SAMPLE_FMT_DBL);
-    src.set_sample_rate(48000);
-    src.set_ch_layout(AVChannelLayout::from_nb_channels(2).into_inner());
-    src.get_buffer(0).unwrap();
-    // For packed formats (non-planar), samples are interleaved per channel in data[0].
-    let mut t = 0.0f64;
-    let samples_mut =
-        unsafe { std::slice::from_raw_parts_mut(src.data[0] as *mut f64, (nb * 2) as usize) };
-    fill_samples(samples_mut, nb as usize, 2, 48000usize, &mut t);
+    // Allocate source samples buffer using AVSamples like C example
+    let src_data = AVSamples::new(src_nb_channels, src_nb_samples, src_sample_fmt, 0).unwrap();
 
-    // dst frame (let swr allocate)
-    let mut dst = AVFrame::new();
-    dst.set_nb_samples(0);
-    dst.set_format(ffi::AV_SAMPLE_FMT_S16);
-    dst.set_sample_rate(44100);
-    dst.set_ch_layout(AVChannelLayout::from_nb_channels(6).into_inner());
+    // Calculate destination buffer size with some extra space for resampling
+    let max_dst_nb_samples = av_rescale_rnd(
+        src_nb_samples as i64,
+        dst_rate as i64,
+        src_rate as i64,
+        ffi::AV_ROUND_UP,
+    ) as i32;
 
-    swr.convert_frame(Some(&src), &mut dst).unwrap();
+    let mut dst_data =
+        AVSamples::new(dst_nb_channels, max_dst_nb_samples, dst_sample_fmt, 1).unwrap();
 
-    // Write interleaved s16 to file: nb_samples * channels * 2 bytes
-    let bytes = (dst.nb_samples as usize) * (dst.ch_layout.nb_channels as usize) * 2usize;
     let mut f = std::fs::File::create(out_path)?;
-    unsafe {
-        let p = dst.data[0] as *const u8;
-        let buf = std::slice::from_raw_parts(p, bytes);
-        f.write_all(buf)?;
+    let mut t = 0.0f64;
+    let mut total_bytes = 0usize;
+
+    // Generate 10 seconds of audio like C example
+    loop {
+        // Generate synthetic audio (sine wave at 440Hz)
+        let samples_mut = unsafe {
+            std::slice::from_raw_parts_mut(
+                src_data.audio_data[0] as *mut f64,
+                (src_nb_samples * src_nb_channels) as usize,
+            )
+        };
+        fill_samples(
+            samples_mut,
+            src_nb_samples as usize,
+            src_nb_channels as usize,
+            src_rate as usize,
+            &mut t,
+        );
+
+        // Calculate actual destination samples needed including buffered samples
+        let dst_nb_samples = av_rescale_rnd(
+            swr.get_delay(src_rate as usize) as i64 + src_nb_samples as i64,
+            dst_rate as i64,
+            src_rate as i64,
+            ffi::AV_ROUND_UP,
+        ) as i32;
+
+        // Reallocate destination buffer if needed
+        if dst_nb_samples > max_dst_nb_samples {
+            dst_data = AVSamples::new(dst_nb_channels, dst_nb_samples, dst_sample_fmt, 1).unwrap();
+        }
+
+        // Convert to destination format
+        let ret = unsafe {
+            swr.convert(
+                dst_data.audio_data.as_mut_ptr(),
+                dst_nb_samples,
+                src_data.audio_data.as_ptr() as *const *const u8,
+                src_nb_samples,
+            )
+        }
+        .unwrap();
+
+        let dst_bufsize = get_bytes_per_sample(dst_sample_fmt).unwrap() as usize
+            * ret as usize
+            * dst_nb_channels as usize;
+
+        println!("t:{:.6} in:{} out:{}", t, src_nb_samples, ret);
+
+        unsafe {
+            let p = dst_data.audio_data[0] as *const u8;
+            let buf = std::slice::from_raw_parts(p, dst_bufsize);
+            f.write_all(buf)?;
+        }
+        total_bytes += dst_bufsize;
+
+        if t >= 10.0 {
+            break;
+        }
     }
-    Ok(bytes)
+
+    let fmt = get_format_from_sample_fmt(dst_sample_fmt).unwrap_or("?");
+    let layout_str = dst_ch_layout
+        .describe()
+        .map(|x| x.to_string_lossy().into_owned())
+        .unwrap_or_else(|_| "unknown".into());
+
+    eprintln!(
+        "Resampling succeeded. Play the output file with the command:\n\
+         ffplay -f {} -channel_layout {} -channels {} -ar {} {}",
+        fmt, layout_str, dst_nb_channels, dst_rate, out_path
+    );
+
+    Ok(total_bytes)
 }
 
 #[test]
