refactor: use ffmpeg 7.x static build, fix compile, update deps

Author: Kingtous

Cargo.lock

@@ -1,9 +1,9 @@
 [package]
 name = "rustplayer"
-version = "1.1.3"
+version = "1.1.4"
 edition = "2021"
 description = "Music/Radio Player built by Rust"
-authors = ["KetaNetwork"]
+authors = ["Kingtous"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -44,8 +44,8 @@ short_description = "Music/Radio Player built by Rust."
 long_description = """
 Music/Radio Player built by Rust.
 """
-deb_depends = ["libasound2", "libavcodec57 | libavcodec58", "libavformat57 | libavformat58", "libswresample2 | libswresample3"]
-osx_minimum_system_version = "10.15"
+deb_depends = ["libasound2"]
+osx_minimum_system_version = "12.0"
 
 [profile]
 release = { strip = "symbols", lto = "thin", opt-level = "z" }

Cargo.toml

@@ -1,7 +1,7 @@
 #[cfg(target_os = "macos")]
 fn emit_minimum_version() {
-    println!("set minimum version to 10.15");
-    println!("cargo:rustc-env=MACOSX_DEPLOYMENT_TARGET=10.15");
+    println!("set minimum version to 12.0");
+    println!("cargo:rustc-env=MACOSX_DEPLOYMENT_TARGET=12.0");
 }
 
 fn configure() {

build.rs

@@ -1,10 +1,10 @@
 name: rustplayer
-version: '1.1.0-2'
+version: '1.1.4-1'
 summary: A local music player && network radio player
 description: |
   RustPlayer is a local music player && network radio player:
 
-base: core18
+base: core20
 confinement: strict
 
 architectures:
@@ -22,21 +22,12 @@ parts:
       snapcraftctl pull
       git apply dynamic-lib.patch
     build-packages:
-      - libasound2-dev
-      - libavcodec-dev
-      - libavformat-dev 
-      - libswresample-dev
-      - libavutil-dev
       - pkg-config
       - libssl-dev
       - clang
       - git
     stage-packages:
       - libasound2
-      - libavcodec57 
-      - libavformat57 
-      - libswresample2 
-      - libavutil55
 
 layout:
   /usr/share/alsa:

snap/snapcraft.yaml

@@ -31,7 +31,7 @@ use std::{
 use m3u8_rs::{MediaPlaylist, Playlist};
 
 use rodio::cpal;
-use rodio::{Decoder, OutputStream, OutputStreamHandle, Sink, Source};
+use rodio::{Decoder, OutputStream, OutputStreamBuilder, Sink, Source};
 use tui::widgets::ListState;
 
 use crate::util::lyrics::Lyrics;
@@ -114,7 +114,6 @@ pub struct MusicPlayer {
     // media: Media,
     // stream
     stream: OutputStream,
-    stream_handle: OutputStreamHandle,
     sink: Sink,
     current_lyric: Option<String>,
     initialized: bool,
@@ -125,15 +124,15 @@ impl Player for MusicPlayer {
         for dev in cpal::available_hosts() {
             println!("{:?}", dev);
         }
-        let (stream, stream_handle) = OutputStream::try_default().unwrap();
-        let sink = Sink::try_new(&stream_handle).unwrap();
+        let builder = OutputStreamBuilder::from_default_device().unwrap();
+        let stream = builder.open_stream_or_fallback().unwrap();
+        let sink = Sink::connect_new(stream.mixer());
         Self {
             current_time: Duration::from_secs(0),
             total_time: Duration::from_secs(0),
             play_list: PlayList { lists: vec![] },
             // media: f,
             stream,
-            stream_handle,
             sink,
             current_lyric: None,
             initialized: false,
@@ -181,14 +180,12 @@ impl Player for MusicPlayer {
                 let top_music = self.play_list.lists.first().unwrap();
                 let f = File::open(top_music.path.as_str()).unwrap();
                 let buf_reader = BufReader::new(f);
-                let (stream, stream_handle) = OutputStream::try_default().unwrap();
-                self.stream = stream;
-                self.stream_handle = stream_handle;
-                let volume = self.volume();
-                self.sink = Sink::try_new(&self.stream_handle).unwrap();
-                self.set_volume(volume);
-                self.sink.append(Decoder::new(buf_reader).unwrap());
-                self.play();
+                if let Ok(data_decoder) = Decoder::new(buf_reader) {
+                    self.sink.append(data_decoder);
+                    self.play();
+                } else {
+                    return false;
+                }
             }
             // for
         } else {
@@ -355,8 +352,11 @@ impl MusicPlayer {
                     // rebuild
                     self.stop();
                     let buf_reader = BufReader::new(f);
-                    let sink = self.stream_handle.play_once(buf_reader).unwrap();
-                    self.sink = sink;
+                    if let Ok(data_decoder) = Decoder::new(buf_reader) {
+                        self.sink.append(data_decoder);
+                    } else {
+                        return false;
+                    }
                     self.play_list.lists.clear();
                 }
                 let mut state = ListState::default();
@@ -398,7 +398,6 @@ pub struct RadioPlayer {
     pub item: Option<RadioItem>,
     pub list: Vec<PlayListItem>,
     stream: OutputStream,
-    stream_handle: OutputStreamHandle,
     sink: Sink,
     is_playing: bool,
     last_playing_id: i32,
@@ -410,15 +409,15 @@ pub struct RadioPlayer {
 
 impl Player for RadioPlayer {
     fn new() -> Self {
-        let (stream, handle) = OutputStream::try_default().unwrap();
-        let sink = Sink::try_new(&handle).unwrap();
+        let builder = OutputStreamBuilder::from_default_device().unwrap();
+        let stream = builder.open_stream_or_fallback().unwrap();
+        let sink = Sink::connect_new(stream.mixer());
         let (tx, rx) = channel();
         empty_cache();
         RadioPlayer {
             item: None,
             list: vec![],
             stream,
-            stream_handle: handle,
             sink,
             is_playing: false,
             last_playing_id: -1,

src/media/player.rs

@@ -2,13 +2,13 @@ use crate::error::Error;
 
 use ffmpeg_sys_next::{
     self, av_frame_alloc, av_frame_free, av_frame_unref, av_freep, av_get_alt_sample_fmt,
-    av_get_bytes_per_sample, av_get_channel_layout_nb_channels, av_get_sample_fmt_name,
+    av_get_bytes_per_sample, av_get_sample_fmt_name,
     av_init_packet, av_packet_unref, av_read_frame, av_sample_fmt_is_planar,
     av_samples_alloc, av_samples_get_buffer_size, avcodec_alloc_context3, avcodec_close,
     avcodec_find_decoder, avcodec_free_context, avcodec_open2, avcodec_parameters_to_context,
     avcodec_receive_frame, avcodec_send_packet, avformat_close_input, avformat_find_stream_info,
-    avformat_open_input, swr_alloc_set_opts, swr_convert, swr_get_out_samples, swr_init, AVCodec,
-    AVCodecContext, AVFormatContext, AVFrame, AVMediaType, AVPacket, AVSampleFormat, AVStream,
+    avformat_open_input, swr_alloc_set_opts2, swr_convert, swr_get_out_samples, swr_init, AVCodec,
+    AVCodecContext, AVFormatContext, AVFrame, AVMediaType, AVPacket, AVSampleFormat, AVStream, AVChannelLayout
 };
 use std::ffi::{CStr, CString};
 use std::path::Path;
@@ -117,7 +117,7 @@ impl Decoder {
     fn convert_and_store_frame(&mut self) {
         let num_samples = self.frame.num_samples();
         let channel_layout = self.frame.channel_layout();
-        let num_channels = unsafe { av_get_channel_layout_nb_channels(channel_layout) };
+        let num_channels = channel_layout.nb_channels;
 
         let extended_data = self.frame.extended_data();
 
@@ -190,10 +190,10 @@ impl Decoder {
         unsafe { av_packet_unref(self.packet.inner.as_mut_ptr()) };
     }
 
-    fn next_sample(&mut self) -> i16 {
+    fn next_sample(&mut self) -> f32 {
         let sample_u8: [u8; 2] = [self.current_frame.remove(0), self.current_frame.remove(0)];
 
-        ((sample_u8[1] as i16) << 8) | sample_u8[0] as i16
+        (((sample_u8[1] as i16) << 8) | sample_u8[0] as i16) as _
     }
 
     fn process_next_frame(&mut self) -> Option<Result<(), Error>> {
@@ -277,7 +277,7 @@ impl Decoder {
 unsafe impl Send for Decoder {}
 
 impl Iterator for Decoder {
-    type Item = i16;
+    type Item = f32;
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
@@ -371,26 +371,29 @@ struct SwrContext {
 
 impl SwrContext {
     fn new(codec_ctx: &CodecContext) -> Result<SwrContext, Error> {
-        let swr_ctx: *mut ffmpeg_sys_next::SwrContext = unsafe {
-            swr_alloc_set_opts(
-                ptr::null_mut(),
-                codec_ctx.channel_layout() as i64,
+        unsafe  {
+            let mut swr_ctx: *mut ffmpeg_sys_next::SwrContext = std::ptr::null_mut();
+
+            let channel_layout = codec_ctx.channel_layout();
+
+            let ret = swr_alloc_set_opts2(
+                &mut swr_ctx,
+                &channel_layout as *const AVChannelLayout,
                 DEFAULT_CONVERSION_FORMAT,
                 codec_ctx.sample_rate(),
-                codec_ctx.channel_layout() as i64,
+                &channel_layout as *const AVChannelLayout,
                 codec_ctx.sample_format(),
                 codec_ctx.sample_rate(),
                 0,
                 ptr::null_mut(),
-            )
-        };
+            );
+            
+            if ret != 0 || swr_ctx.is_null() {
+                return Err(Error::InitializeSwr);
+            }
 
-        let status = unsafe { swr_init(swr_ctx) };
-        if status != 0 {
-            return Err(Error::InitializeSwr);
+            Ok(SwrContext { inner: swr_ctx })
         }
-
-        Ok(SwrContext { inner: swr_ctx })
     }
 }
 
@@ -427,8 +430,8 @@ impl Frame {
         unsafe { self.inner.as_ref().unwrap().nb_samples }
     }
 
-    fn channel_layout(&self) -> u64 {
-        unsafe { self.inner.as_ref().unwrap().channel_layout }
+    fn channel_layout(&self) -> AVChannelLayout {
+        unsafe { self.inner.as_ref().unwrap().ch_layout }
     }
 
     fn extended_data(&self) -> *mut *const u8 {
@@ -531,11 +534,11 @@ impl CodecContext {
     }
 
     fn channels(&self) -> i32 {
-        unsafe { self.inner.as_ref().unwrap().channels }
+        unsafe { self.inner.as_ref().unwrap().ch_layout.nb_channels }
     }
 
-    fn channel_layout(&self) -> u64 {
-        unsafe { self.inner.as_ref().unwrap().channel_layout }
+    fn channel_layout(&self) -> AVChannelLayout {
+        unsafe { self.inner.as_ref().unwrap().ch_layout }
     }
 
     fn is_planar(&self) -> i32 {

thirdparty/ffmpeg-decoder-rs/src/decoder.rs

@@ -6,7 +6,7 @@ use std::time::Duration;
 
 impl Source for Decoder {
     #[inline]
-    fn current_frame_len(&self) -> Option<usize> {
+    fn current_span_len(&self) -> Option<usize> {
         self._current_frame_len()
     }