08.03.2024

* FFmpeg feature implemented
* `bytes` create implemented for download functions
* Unhandled download panic fixed (thanks @Timtam)

Author: Mithronn

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rusty_ytdl"
-version = "0.6.7"
+version = "0.7.0"
 authors = ["Mithronn"]
 edition = "2021"
 description = "A Rust library for Youtube video searcher and downloader"
@@ -55,7 +55,7 @@ bytes = "1.5.0"
 tokio = { version = "1.36.0", features = ["full"] }
 
 [features]
-default = ["search", "live", "default-tls", "ffmpeg"]
+default = ["search", "live", "default-tls"]
 live = ["tokio/time", "tokio/process"]
 blocking = ["tokio/rt", "tokio/rt-multi-thread"]
 search = []

README.md

@@ -19,7 +19,7 @@ Download videos **blazing-fast** without getting stuck on Youtube download speed
 
 ## Roadmap
 
-- [ ] ffmpeg feature
+- [x] ffmpeg feature
 - [ ] benchmarks
 
 ## Features
@@ -28,6 +28,7 @@ Download videos **blazing-fast** without getting stuck on Youtube download speed
 - Search with query (Video, Playlist, Channel)
 - Blocking and asynchronous API
 - Proxy, IPv6, and cookie support on request
+- Built-in FFmpeg audio and video filter apply support. [Example](examples/download_with_ffmpeg.rs)
 - [CLI](https://crates.io/crates/rusty_ytdl-cli)
 
 # Usage
@@ -158,5 +159,5 @@ Or add the following to your `Cargo.toml` file:
 
 ```toml
 [dependencies]
-rusty_ytdl = "0.6.7"
+rusty_ytdl = "0.7.0"
 ```

cli/Cargo.toml

@@ -30,7 +30,7 @@ tokio = { version = "1.28.2", features = [
     "io-std",
 ] }
 log = "0.4.20"
-rusty_ytdl = { path = "..", version = "0.6.7" }
+rusty_ytdl = { path = "..", version = "0.7.0" }
 colored = { version = "2.0.0" }
 indicatif = "0.17.4"
 fern = { version = "0.6.2", features = ["colored"] }

examples/download_with_ffmpeg.rs

@@ -0,0 +1,30 @@
+#[tokio::main]
+async fn main() {
+    #[cfg(feature = "ffmpeg")]
+    {
+        use rusty_ytdl::{FFmpegArgs, Video, VideoOptions, VideoQuality, VideoSearchOptions};
+
+        let url = "FZ8BxMU3BYc";
+
+        let video_options = VideoOptions {
+            quality: VideoQuality::Highest,
+            filter: VideoSearchOptions::VideoAudio,
+            ..Default::default()
+        };
+
+        let video = Video::new_with_options(url, video_options).unwrap();
+
+        let stream = video
+            .stream_with_ffmpeg(Some(FFmpegArgs {
+                format: Some("mp3".to_string()),
+                audio_filter: Some("aresample=48000,asetrate=48000*0.8".to_string()),
+                video_filter: Some("eq=brightness=150:saturation=2".to_string()),
+            }))
+            .await
+            .unwrap();
+
+        while let Some(chunk) = stream.chunk().await.unwrap() {
+            println!("{:#?}", chunk);
+        }
+    }
+}

src/blocking/info.rs

@@ -56,10 +56,7 @@ impl Video {
     ///           println!("{:#?}", chunk);
     ///     }
     /// ```
-    pub fn stream(
-        &self,
-        #[cfg(feature = "ffmpeg")] ffmpeg_args: Option<FFmpegArgs>,
-    ) -> Result<Box<dyn Stream + Send + Sync>, VideoError> {
+    pub fn stream(&self) -> Result<Box<dyn Stream + Send + Sync>, VideoError> {
         let client = self.0.get_client();
 
         let options = self.0.get_options();
@@ -81,25 +78,21 @@ impl Video {
                 let stream = LiveStream::new(LiveStreamOptions {
                     client: Some(client.clone()),
                     stream_url: link,
-                });
-
-                if stream.is_err() {
-                    return Err(stream.err().unwrap());
-                }
+                })?;
 
-                return Ok(Box::new(stream.unwrap()));
+                return Ok(Box::new(stream));
             }
             #[cfg(not(feature = "live"))]
             {
                 return Err(VideoError::LiveStreamNotSupported);
             }
         }
 
-        let dl_chunk_size = if options.download_options.dl_chunk_size.is_some() {
-            options.download_options.dl_chunk_size.unwrap()
-        } else {
-            1024 * 1024 * 10_u64 // -> Default is 10MB to avoid Youtube throttle (Bigger than this value can be throttle by Youtube)
-        };
+        let dl_chunk_size = options
+            .download_options
+            .dl_chunk_size
+            // 1024 * 1024 * 10_u64 -> Default is 10MB to avoid Youtube throttle (Bigger than this value can be throttle by Youtube)
+            .unwrap_or(1024 * 1024 * 10_u64);
 
         let start = 0;
         let end = start + dl_chunk_size;
@@ -114,13 +107,102 @@ impl Video {
         if content_length == 0 {
             let content_length_response = block_async!(client.get(&link).send())
                 .map_err(VideoError::ReqwestMiddleware)?
-                .content_length();
+                .content_length()
+                .ok_or(VideoError::VideoNotFound)?;
+
+            content_length = content_length_response;
+        }
+
+        let stream = NonLiveStream::new(NonLiveStreamOptions {
+            client: Some(client.clone()),
+            link,
+            content_length,
+            dl_chunk_size,
+            start,
+            end,
+            #[cfg(feature = "ffmpeg")]
+            ffmpeg_args: None,
+        })?;
 
-            if content_length_response.is_none() {
-                return Err(VideoError::VideoNotFound);
+        Ok(Box::new(stream))
+    }
+
+    #[cfg(feature = "ffmpeg")]
+    /// Try to turn [`Stream`] implemented [`LiveStream`] or [`NonLiveStream`] depend on the video with [`FFmpegArgs`].
+    /// If function successfully return can download video with applied ffmpeg filters and formats chunk by chunk
+    /// # Example
+    /// ```ignore
+    ///     let video_url = "https://www.youtube.com/watch?v=FZ8BxMU3BYc";
+    ///
+    ///     let video = Video::new(video_url).unwrap();
+    ///
+    ///     let stream = video.stream().await.unwrap();
+    ///
+    ///     while let Some(chunk) = stream.chunk().await.unwrap() {
+    ///           println!("{:#?}", chunk);
+    ///     }
+    /// ```
+    pub async fn stream_with_ffmpeg(
+        &self,
+        ffmpeg_args: Option<FFmpegArgs>,
+    ) -> Result<Box<dyn Stream + Send + Sync>, VideoError> {
+        let client = self.0.get_client();
+
+        let options = self.0.get_options();
+
+        let info = block_async!(self.0.get_info())?;
+        let format = choose_format(&info.formats, &options)
+            .map_err(|_op| VideoError::VideoSourceNotFound)?;
+
+        let link = format.url;
+
+        if link.is_empty() {
+            return Err(VideoError::VideoSourceNotFound);
+        }
+
+        // Only check for HLS formats for live streams
+        if format.is_hls {
+            #[cfg(feature = "live")]
+            {
+                let stream = LiveStream::new(LiveStreamOptions {
+                    client: Some(client.clone()),
+                    stream_url: link,
+                })?;
+
+                return Ok(Box::new(stream));
             }
+            #[cfg(not(feature = "live"))]
+            {
+                return Err(VideoError::LiveStreamNotSupported);
+            }
+        }
+
+        let dl_chunk_size = options
+            .download_options
+            .dl_chunk_size
+            // 1024 * 1024 * 10_u64 -> Default is 10MB to avoid Youtube throttle (Bigger than this value can be throttle by Youtube)
+            .unwrap_or(1024 * 1024 * 10_u64);
 
-            content_length = content_length_response.unwrap();
+        let start = 0;
+        let end = start + dl_chunk_size;
+
+        let mut content_length = format
+            .content_length
+            .unwrap_or("0".to_string())
+            .parse::<u64>()
+            .unwrap_or(0);
+
+        // Get content length from source url if content_length is 0
+        if content_length == 0 {
+            let content_length_response = client
+                .get(&link)
+                .send()
+                .await
+                .map_err(VideoError::ReqwestMiddleware)?
+                .content_length()
+                .ok_or(VideoError::VideoNotFound)?;
+
+            content_length = content_length_response;
         }
 
         let stream = NonLiveStream::new(NonLiveStreamOptions {
@@ -130,28 +212,27 @@ impl Video {
             dl_chunk_size,
             start,
             end,
-            #[cfg(feature = "ffmpeg")]
             ffmpeg_args,
         })?;
 
         Ok(Box::new(stream))
     }
 
     /// Download video directly to the file
-    pub fn download<P: AsRef<std::path::Path>>(
+    pub fn download<P: AsRef<std::path::Path>>(&self, path: P) -> Result<(), VideoError> {
+        Ok(block_async!(self.0.download(path))?)
+    }
+
+    #[cfg(feature = "ffmpeg")]
+    /// Download video with ffmpeg args directly to the file
+    pub async fn download_with_ffmpeg<P: AsRef<std::path::Path>>(
         &self,
         path: P,
-        #[cfg(feature = "ffmpeg")] ffmpeg_args: Option<FFmpegArgs>,
+        ffmpeg_args: Option<FFmpegArgs>,
     ) -> Result<(), VideoError> {
-        #[cfg(feature = "ffmpeg")]
-        {
-            Ok(block_async!(self.0.download(path, ffmpeg_args))?)
-        }
-
-        #[cfg(not(feature = "ffmpeg"))]
-        {
-            Ok(block_async!(self.0.download(path))?)
-        }
+        Ok(block_async!(self
+            .0
+            .download_with_ffmpeg(path, ffmpeg_args))?)
     }
 
     /// Get video URL

src/blocking/stream/streams/live.rs

@@ -1,3 +1,5 @@
+use bytes::Bytes;
+
 use crate::blocking::stream::Stream;
 use crate::stream::{LiveStream as AsyncLiveStream, LiveStreamOptions};
 use crate::{block_async, VideoError};
@@ -11,7 +13,7 @@ impl LiveStream {
 }
 
 impl Stream for LiveStream {
-    fn chunk(&self) -> Result<Option<Vec<u8>>, VideoError> {
+    fn chunk(&self) -> Result<Option<Bytes>, VideoError> {
         use crate::stream::Stream;
         Ok(block_async!(self.0.chunk())?)
     }

src/blocking/stream/streams/mod.rs

@@ -1,3 +1,5 @@
+use bytes::Bytes;
+
 #[cfg(feature = "live")]
 pub use crate::stream::LiveStreamOptions;
 pub use crate::stream::NonLiveStreamOptions;
@@ -16,7 +18,7 @@ pub trait Stream {
     /// Stream a chunk of the [`u8`] bytes
     ///
     /// When the bytes has been exhausted, this will return `None`.
-    fn chunk(&self) -> Result<Option<Vec<u8>>, VideoError>;
+    fn chunk(&self) -> Result<Option<Bytes>, VideoError>;
 
     /// Content length of the stream
     ///

src/blocking/stream/streams/non_live.rs

@@ -1,3 +1,5 @@
+use bytes::Bytes;
+
 use crate::blocking::stream::Stream;
 use crate::stream::{NonLiveStream as AsyncNonLiveStream, NonLiveStreamOptions};
 use crate::{block_async, VideoError};
@@ -11,7 +13,7 @@ impl NonLiveStream {
 }
 
 impl Stream for NonLiveStream {
-    fn chunk(&self) -> Result<Option<Vec<u8>>, VideoError> {
+    fn chunk(&self) -> Result<Option<Bytes>, VideoError> {
         use crate::stream::Stream;
         Ok(block_async!(self.0.chunk())?)
     }