first commit

Author: Fredolx

src-tauri/Cargo.lock

@@ -41,6 +41,7 @@ log = "0.4.22"
 rusqlite_migration = "1.3.1"
 base64 = "0.22.1"
 tauri-plugin-notification = "2.2.0"
+warp = "0.3.7"
 [target.'cfg(any(target_os = "linux", target_os = "macos"))'.dependencies]
 shell-words = "1.1.0"
 [target.'cfg(target_os = "windows")'.dependencies]

src-tauri/Cargo.toml

@@ -1,7 +1,7 @@
 use std::{
     sync::{
         atomic::{AtomicBool, Ordering::Relaxed},
-        Arc, Mutex,
+        Arc,
     },
     thread::{self, sleep},
     time::Duration,
@@ -11,6 +11,7 @@ use anyhow::{Context, Result};
 use chrono::Local;
 use tauri::{AppHandle, State};
 use tauri_plugin_notification::NotificationExt;
+use tokio::sync::Mutex;
 
 use crate::{
     log, sql,
@@ -57,8 +58,12 @@ fn is_timestamp_over(timestamp: i64) -> Result<bool> {
     Ok(current_time >= time)
 }
 
-pub fn add_epg(state: State<'_, Mutex<AppState>>, app: AppHandle, epg: EPGNotify) -> Result<()> {
-    let mut state = state.lock().unwrap();
+pub async fn add_epg(
+    state: State<'_, Mutex<AppState>>,
+    app: AppHandle,
+    epg: EPGNotify,
+) -> Result<()> {
+    let mut state = state.lock().await;
     if state.thread_handle.is_some() {
         state.notify_stop.store(true, Relaxed);
         let _ = state
@@ -78,8 +83,12 @@ pub fn add_epg(state: State<'_, Mutex<AppState>>, app: AppHandle, epg: EPGNotify
     Ok(())
 }
 
-pub fn remove_epg(state: State<'_, Mutex<AppState>>, app: AppHandle, epg_id: String) -> Result<()> {
-    let mut state = state.lock().unwrap();
+pub async fn remove_epg(
+    state: State<'_, Mutex<AppState>>,
+    app: AppHandle,
+    epg_id: String,
+) -> Result<()> {
+    let mut state = state.lock().await;
     if state.thread_handle.is_some() {
         state.notify_stop.store(true, Relaxed);
         let _ = state
@@ -102,13 +111,13 @@ pub fn remove_epg(state: State<'_, Mutex<AppState>>, app: AppHandle, epg_id: Str
     Ok(())
 }
 
-pub fn on_start_check_epg(state: State<'_, Mutex<AppState>>, app: AppHandle) -> Result<()> {
+pub async fn on_start_check_epg(state: State<'_, Mutex<AppState>>, app: AppHandle) -> Result<()> {
     sql::clean_epgs()?;
     let list = sql::get_epgs()?;
     if list.len() == 0 {
         return Ok(());
     }
-    let mut state = state.lock().unwrap();
+    let mut state = state.lock().await;
     state.notify_stop.store(false, Relaxed);
     let stop = state.notify_stop.clone();
     state

src-tauri/src/epg.rs

@@ -1,11 +1,10 @@
-use std::sync::Mutex;
-
 use anyhow::Error;
 use tauri::{
     menu::{Menu, MenuItem},
     tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent},
     AppHandle, Manager, State,
 };
+use tokio::sync::Mutex;
 use types::{
     AppState, Channel, CustomChannel, CustomChannelExtraData, EPGNotify, Filters, Group, IdName,
     Settings, Source, EPG,
@@ -16,6 +15,7 @@ pub mod log;
 pub mod m3u;
 pub mod media_type;
 pub mod mpv;
+pub mod restream;
 pub mod settings;
 pub mod share;
 pub mod source_type;
@@ -80,7 +80,9 @@ pub fn run() {
             add_epg,
             remove_epg,
             get_epg_ids,
-            on_start_check_epg
+            on_start_check_epg,
+            start_restream,
+            stop_restream
         ])
         .setup(|app| {
             app.manage(Mutex::new(AppState {
@@ -95,14 +97,14 @@ pub fn run() {
                 .on_menu_event(|app, event| match event.id.as_ref() {
                     "quit" => {
                         app.exit(0);
-                    },
+                    }
                     "show" => {
                         if let Some(window) = app.get_webview_window("main") {
                             let _ = window.unminimize();
                             let _ = window.show();
                             let _ = window.set_focus();
                         }
-                    },
+                    }
                     _ => {}
                 })
                 .on_tray_icon_event(|tray, event| match event {
@@ -362,30 +364,53 @@ async fn download(app: AppHandle, channel: Channel) -> Result<(), String> {
         .map_err(map_err_frontend)
 }
 
-#[tauri::command(async)]
-fn add_epg(
+#[tauri::command]
+async fn add_epg(
     state: State<'_, Mutex<AppState>>,
     app: AppHandle,
     epg: EPGNotify,
 ) -> Result<(), String> {
-    epg::add_epg(state, app, epg).map_err(map_err_frontend)
+    epg::add_epg(state, app, epg)
+        .await
+        .map_err(map_err_frontend)
 }
 
 #[tauri::command(async)]
-fn remove_epg(
+async fn remove_epg(
     state: State<'_, Mutex<AppState>>,
     app: AppHandle,
     epg_id: String,
 ) -> Result<(), String> {
-    epg::remove_epg(state, app, epg_id).map_err(map_err_frontend)
+    epg::remove_epg(state, app, epg_id)
+        .await
+        .map_err(map_err_frontend)
 }
 
 #[tauri::command(async)]
 fn get_epg_ids() -> Result<Vec<String>, String> {
     sql::get_epg_ids().map_err(map_err_frontend)
 }
 
-#[tauri::command(async)]
-fn on_start_check_epg(state: State<'_, Mutex<AppState>>, app: AppHandle) -> Result<(), String> {
-    epg::on_start_check_epg(state, app).map_err(map_err_frontend)
+#[tauri::command]
+async fn on_start_check_epg(
+    state: State<'_, Mutex<AppState>>,
+    app: AppHandle,
+) -> Result<(), String> {
+    epg::on_start_check_epg(state, app)
+        .await
+        .map_err(map_err_frontend)
+}
+
+#[tauri::command]
+async fn start_restream(state: State<'_, Mutex<AppState>>, channel: Channel) -> Result<(), String> {
+    crate::restream::start_restream(state, channel)
+        .await
+        .map_err(map_err_frontend)
+}
+
+#[tauri::command]
+async fn stop_restream(state: State<'_, Mutex<AppState>>) -> Result<(), String> {
+    crate::restream::stop_restream(state)
+        .await
+        .map_err(map_err_frontend)
 }

src-tauri/src/lib.rs

@@ -0,0 +1,116 @@
+use std::{
+    path::PathBuf,
+    process::{Child, Command},
+};
+
+use anyhow::{Context, Result};
+use tauri::State;
+use tokio::sync::{
+    oneshot::{self, Sender},
+    Mutex,
+};
+
+use crate::{
+    log::log,
+    sql,
+    types::{AppState, Channel},
+};
+
+fn start_ffmpeg_listening(channel: Channel) -> Result<Child> {
+    let headers = sql::get_channel_headers_by_id(channel.id.context("no channel id")?)?;
+    let mut playlist_dir = get_playlist_dir()?;
+    let mut command = Command::new("ffmpeg");
+    command
+        .arg("-i")
+        .arg(channel.url.context("no channel url")?);
+    if let Some(headers) = headers {
+        if let Some(referrer) = headers.referrer {
+            command.arg("-headers");
+            command.arg(format!("Referer: {referrer}"));
+        }
+        if let Some(user_agent) = headers.user_agent {
+            command.arg("-headers");
+            command.arg(format!("User-Agent: {user_agent}"));
+        }
+        if let Some(origin) = headers.http_origin {
+            command.arg("-headers");
+            command.arg(format!("Origin: {origin}"));
+        }
+        if let Some(ignore_ssl) = headers.ignore_ssl {
+            if ignore_ssl {
+                command.arg("-tls_verify");
+                command.arg("0");
+            }
+        }
+    }
+    let child = command
+        .arg("-c")
+        .arg("copy")
+        .arg("-f")
+        .arg("hls")
+        .arg("-hls_time")
+        .arg("5")
+        .arg("-hls_list_size")
+        .arg("6")
+        .arg("-hls_flags")
+        .arg("delete_segments")
+        .arg(playlist_dir)
+        .spawn()?;
+    Ok(child)
+}
+
+async fn start_web_server() -> Result<(Sender<bool>, tokio::task::JoinHandle<()>)> {
+    let files_dir = get_restream_folder()?;
+    let file_server = warp::fs::dir(files_dir);
+    let (tx, rx) = oneshot::channel::<bool>();
+    let (_, server) =
+        warp::serve(file_server).bind_with_graceful_shutdown(([0, 0, 0, 0], 3000), async {
+            rx.await.ok();
+        });
+    let handle = tokio::spawn(server);
+    return Ok((tx, handle));
+}
+
+pub async fn start_restream(state: State<'_, Mutex<AppState>>, channel: Channel) -> Result<()> {
+    let mut state = state.lock().await;
+    state.ffmpeg_child = Some(start_ffmpeg_listening(channel)?);
+    (state.web_server_tx, state.web_server_handle) = start_web_server()
+        .await
+        .map(|(tx, handle)| (Some(tx), Some(handle)))?;
+    Ok(())
+}
+
+pub async fn stop_restream(state: State<'_, Mutex<AppState>>) -> Result<()> {
+    let mut state = state.lock().await;
+    let mut ffmpeg_child = state.ffmpeg_child.take().context("no ffmpeg child")?;
+    let web_server_tx = state.web_server_tx.take().context("no web server tx")?;
+    let web_server_handle = state
+        .web_server_handle
+        .take()
+        .context("no web server handle")?;
+    let _ = ffmpeg_child.kill();
+    let _ = web_server_tx.send(true);
+    let _ = ffmpeg_child.wait();
+    let _ = web_server_handle
+        .await
+        .unwrap_or_else(|e| log(format!("{:?}", e)));
+    Ok(())
+}
+
+fn get_playlist_dir() -> Result<String> {
+    let mut restream_folder = get_restream_folder()?;
+    restream_folder.push("stream.m3u8");
+    Ok(restream_folder.to_string_lossy().to_string())
+}
+
+fn get_restream_folder() -> Result<PathBuf> {
+    let mut path = directories::ProjectDirs::from("dev", "fredol", "open-tv")
+        .context("can't find project folder")?
+        .cache_dir()
+        .to_owned();
+    path.push("restream");
+    if !path.exists() {
+        std::fs::create_dir_all(&path).unwrap();
+    }
+    Ok(path)
+}

src-tauri/src/restream.rs

@@ -140,4 +140,7 @@ pub struct EPGNotify {
 pub struct AppState {
     pub notify_stop: Arc<AtomicBool>,
     pub thread_handle: Option<JoinHandle<Result<(), anyhow::Error>>>,
+    pub ffmpeg_child: Option<std::process::Child>,
+    pub web_server_tx: Option<tokio::sync::oneshot::Sender<bool>>,
+    pub web_server_handle: Option<tokio::task::JoinHandle<()>>,
 }

src-tauri/src/types.rs

@@ -0,0 +1,16 @@
+#EXTM3U
+#EXT-X-VERSION:3
+#EXT-X-TARGETDURATION:5
+#EXT-X-MEDIA-SEQUENCE:14
+#EXTINF:5.005000,
+stream14.ts
+#EXTINF:5.005000,
+stream15.ts
+#EXTINF:5.005000,
+stream16.ts
+#EXTINF:5.005000,
+stream17.ts
+#EXTINF:5.005000,
+stream18.ts
+#EXTINF:5.005000,
+stream19.ts

src-tauri/stream.m3u8

@@ -27,6 +27,7 @@ import { ImportModalComponent } from './import-modal/import-modal.component';
 import { ConfirmDeleteModalComponent } from './confirm-delete-modal/confirm-delete-modal.component';
 import { EpgModalComponent } from './epg-modal/epg-modal.component';
 import { EpgModalItemComponent } from './epg-modal/epg-modal-item/epg-modal-item.component';
+import { RestreamModalComponent } from './restream-modal/restream-modal.component';
 
 @NgModule({
   declarations: [
@@ -49,6 +50,7 @@ import { EpgModalItemComponent } from './epg-modal/epg-modal-item/epg-modal-item
     ConfirmDeleteModalComponent,
     EpgModalComponent,
     EpgModalItemComponent,
+    RestreamModalComponent,
   ],
   imports: [
     BrowserModule,

src/app/app.module.ts

@@ -45,6 +45,9 @@
     <button [hidden]="!showEPG()" mat-menu-item (click)="showEPGModal()">EPG</button>
     <button [hidden]="!isCustom()" mat-menu-item (click)="edit()">Edit</button>
     <button [hidden]="!isCustom()" mat-menu-item (click)="share()">Share</button>
+    <button [hidden]="!isLivestream()" mat-menu-item (click)="openRestreamModal()">
+      Re-stream
+    </button>
     <button [hidden]="!isCustom()" mat-menu-item (click)="delete()">Delete</button>
   </ng-template>
 </mat-menu>

src/app/channel-tile/channel-tile.component.html

@@ -22,6 +22,7 @@ import { SourceType } from "../models/sourceType";
 import { EpgModalComponent } from "../epg-modal/epg-modal.component";
 import { EPG } from "../models/epg";
 import { listen, UnlistenFn } from "@tauri-apps/api/event";
+import { RestreamModalComponent } from "../restream-modal/restream-modal.component";
 
 @Component({
   selector: "app-channel-tile",
@@ -284,6 +285,16 @@ export class ChannelTileComponent implements OnDestroy, AfterViewInit {
     this.memory.ModalRef.componentInstance.group = { ...this.channel };
   }
 
+  openRestreamModal() {
+    this.memory.ModalRef = this.modal.open(RestreamModalComponent, {
+      backdrop: "static",
+      size: "xl",
+      keyboard: false,
+    });
+    this.memory.ModalRef.componentInstance.channel = this.channel;
+    this.memory.ModalRef.result.then((_) => (this.memory.ModalRef = undefined));
+  }
+
   async deleteChannel() {
     await this.memory.tryIPC("Successfully deleted channel", "Failed to delete channel", () =>
       invoke("delete_custom_channel", { id: this.channel?.id }),

src/app/channel-tile/channel-tile.component.ts

@@ -0,0 +1,10 @@
+<div class="modal-header">
+  <h4 class="modal-title lbl">Re-streaming...</h4>
+</div>
+<div class="modal-body">
+  <p class="notice">Your re-stream server is active</p>
+</div>
+<div class="modal-footer">
+  <button (click)="start()" class="btn btn-primary">Start</button>
+  <button (click)="stop()" class="btn btn-danger">Stop</button>
+</div>