Merge pull request #177 from nikitos/hls_params3

Use config struct to pass hls params

Author: harlanc

Cargo.lock

@@ -333,10 +333,7 @@ impl Service {
             let mut hls_remuxer = HlsRemuxer::new(
                 cient_event_consumer,
                 event_producer,
-                hls_cfg_value.need_record,
-                hls_cfg_value.path.clone(),
-                hls_cfg_value.fragment,
-                hls_cfg_value.aof_ratio,
+                self.cfg.hls.clone(),
             );
 
             tokio::spawn(async move {

application/xiu/src/service.rs

@@ -78,6 +78,7 @@ impl Config {
                 path: None,
                 fragment: None,
                 aof_ratio: None,
+                live_ts_count: None,
             });
         }
 
@@ -154,6 +155,7 @@ pub struct HlsConfig {
     pub path: Option<String>,
     pub fragment: Option<i64>,
     pub aof_ratio: Option<i64>,
+    pub live_ts_count: Option<usize>,
 }
 
 pub enum LogLevel {

library/config/src/lib.rs

@@ -22,6 +22,7 @@ streamhub = { path = "../../library/streamhub/" }
 xmpegts = { path = "../../library/container/mpegts/" }
 xflv = { path = "../../library/container/flv/" }
 commonlib = { path = "../../library/common/" }
+config = { path = "../../library/config/" }
 
 [dependencies.tokio]
 version = "1.4.0"

protocol/hls/Cargo.toml

@@ -1,15 +1,13 @@
 use {
-    super::{define::FlvDemuxerData, errors::MediaError, m3u8::M3u8},
-    bytes::BytesMut,
-    xflv::{
+    super::{define::FlvDemuxerData, errors::MediaError, m3u8::M3u8}, bytes::BytesMut, config::HlsConfig, xflv::{
         define::{frame_type, FlvData},
         demuxer::{FlvAudioTagDemuxer, FlvVideoTagDemuxer},
     },
     streamhub::{define::{StreamHubEventSender, StreamHubEvent}, stream::StreamIdentifier},
     xmpegts::{
         define::{epsi_stream_type, MPEG_FLAG_IDR_FRAME},
         ts::TsMuxer,
-    },
+    }
 };
 
 pub struct Flv2HlsRemuxer {
@@ -40,13 +38,10 @@ pub struct Flv2HlsRemuxer {
 
 impl Flv2HlsRemuxer {
     pub fn new(
-        duration: i64,
         app_name: String,
         stream_name: String,
-        need_record: bool,
+        hls_config: Option<HlsConfig>,
         event_producer: Option<StreamHubEventSender>,
-        path: String,
-        aof_ratio: i64,
     ) -> Self {
         let mut ts_muxer = TsMuxer::new();
         let audio_pid = ts_muxer
@@ -55,7 +50,17 @@ impl Flv2HlsRemuxer {
         let video_pid = ts_muxer
             .add_stream(epsi_stream_type::PSI_STREAM_H264, BytesMut::new())
             .unwrap();
-
+        
+        let duration = hls_config
+            .as_ref() 
+            .and_then(|config| config.fragment)
+            .unwrap_or(5);
+        
+        let aof_ratio = hls_config
+            .as_ref() 
+            .and_then(|config| config.aof_ratio)
+            .unwrap_or(5);
+        
         Self {
             video_demuxer: FlvVideoTagDemuxer::new(),
             audio_demuxer: FlvAudioTagDemuxer::new(),
@@ -74,7 +79,7 @@ impl Flv2HlsRemuxer {
             video_pid,
             audio_pid,
 
-            m3u8_handler: M3u8::new(duration, 6, app_name.clone(), stream_name.clone(), need_record, path),
+            m3u8_handler: M3u8::new(duration, app_name.clone(), stream_name.clone(), hls_config),
             event_producer,
             app_name,
             stream_name,

protocol/hls/src/flv2hls.rs

@@ -5,6 +5,7 @@ use {
         errors::{HlsError, HlsErrorValue},
         flv2hls::Flv2HlsRemuxer,
     },
+    config::HlsConfig,
     std::time::Duration,
     streamhub::{
         define::{
@@ -34,10 +35,7 @@ impl FlvDataReceiver {
         app_name: String,
         stream_name: String,
         event_producer: StreamHubEventSender,
-        duration: i64,
-        need_record: bool,
-        path: String,
-        aof_ratio: i64,
+        hls_config: Option<HlsConfig>,
     ) -> Self {
         let (_, data_consumer) = mpsc::unbounded_channel();
         let subscriber_id = Uuid::new(RandomDigitCount::Four);
@@ -47,7 +45,7 @@ impl FlvDataReceiver {
             stream_name: stream_name.clone(),
             data_consumer,
             event_producer: event_producer.clone(),
-            media_processor: Flv2HlsRemuxer::new(duration, app_name, stream_name, need_record, Some(event_producer), path, aof_ratio),
+            media_processor: Flv2HlsRemuxer::new(app_name, stream_name, hls_config, Some(event_producer)),
             subscriber_id,
         }
     }

protocol/hls/src/flv_data_receiver.rs

@@ -1,5 +1,6 @@
 use {
     super::{errors::MediaError, ts::Ts},
+    config::HlsConfig,
     bytes::BytesMut,
     std::{collections::VecDeque, fs, fs::File, io::Write},
     streamhub::define::Segment,
@@ -32,16 +33,30 @@ pub struct M3u8 {
 impl M3u8 {
     pub fn new(
         duration: i64,
-        live_ts_count: usize,
         app_name: String,
         stream_name: String,
-        need_record: bool,
-        path: String,
+        hls_config: Option<HlsConfig>,
     ) -> Self {
+
+        let path = hls_config
+            .as_ref() 
+            .and_then(|config| config.path.clone())
+            .unwrap_or("./".to_string());
+
         let m3u8_folder = format!("{path}{app_name}/{stream_name}");
         fs::create_dir_all(m3u8_folder.clone()).unwrap();
-
         let live_m3u8_name = format!("{stream_name}.m3u8");
+
+        let need_record = hls_config
+            .as_ref() 
+            .and_then(|config| Some(config.need_record))
+            .unwrap_or(false);
+
+        let live_ts_count = hls_config
+            .as_ref() 
+            .and_then(|config| config.live_ts_count)
+            .unwrap_or(6); 
+
         let vod_m3u8_name = if need_record {
             format!("vod_{stream_name}.m3u8")
         } else {

protocol/hls/src/m3u8.rs

@@ -1,5 +1,6 @@
 use {
     super::{errors::HlsError, flv_data_receiver::FlvDataReceiver},
+    config::HlsConfig,
     streamhub::{
         define::{BroadcastEvent, BroadcastEventReceiver, StreamHubEventSender},
         stream::StreamIdentifier,
@@ -9,28 +10,19 @@ use {
 pub struct HlsRemuxer {
     client_event_consumer: BroadcastEventReceiver,
     event_producer: StreamHubEventSender,
-    need_record: bool,
-    path: String,
-    fragment: i64,
-    aof_ratio: i64,
+    hls_config: Option<HlsConfig>,
 }
 
 impl HlsRemuxer {
     pub fn new(
         consumer: BroadcastEventReceiver,
         event_producer: StreamHubEventSender,
-        need_record: bool,
-        path: Option<String>,
-        fragment: Option<i64>,
-        aof_ratio: Option<i64>,
+        hls_config: Option<HlsConfig>
     ) -> Self {
         Self {
             client_event_consumer: consumer,
             event_producer,
-            need_record,
-            path: path.unwrap_or("./".to_string()),
-            fragment: fragment.unwrap_or(2),
-            aof_ratio: aof_ratio.unwrap_or(1),
+            hls_config,
         }
     }
 
@@ -48,10 +40,7 @@ impl HlsRemuxer {
                             app_name,
                             stream_name,
                             self.event_producer.clone(),
-                            self.fragment,
-                            self.need_record,
-                            self.path.clone(),
-                            self.aof_ratio,
+                            self.hls_config.clone(),
                         );
 
                         tokio::spawn(async move {

protocol/hls/src/remuxer.rs

@@ -65,7 +65,7 @@ mod tests {
 
         let start = Instant::now();
         let mut media_demuxer =
-            Flv2HlsRemuxer::new(5, String::from("live"), String::from("test"), false, None, String::from("./"), 1);
+            Flv2HlsRemuxer::new(String::from("live"), String::from("test"), None, None);
 
         loop {
             let data_ = demuxer.read_flv_tag();