tauri: [bug] Asset protocol crashes app with large video files

I think I figured out the problem, could you apply this patch to your repro and see if it fixes the issue for your?

diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index 6561691..2682f1f 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -17,6 +17,10 @@ tauri-build = { version = "1.2", features = [] }
 serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 tauri = { version = "1.2", features = ["devtools", "dialog-open", "protocol-asset", "shell-open"] }
+percent-encoding = "2.2.0"
+url = "2.3.1"
+http-range-header = "0.3.0"
+rand = "0.8.5"
 
 [features]
 # by default Tauri runs in production mode
diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
index 3cd46c4..2ca41eb 100644
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
@@ -3,9 +3,157 @@
     windows_subsystem = "windows"
 )]
 
+use std::io::{Read, Seek, SeekFrom, Write};
+use tauri::http::{
+    header::{ACCEPT_RANGES, CONTENT_LENGTH, CONTENT_RANGE, CONTENT_TYPE, RANGE},
+    status::StatusCode,
+    MimeType, ResponseBuilder,
+};
+use url::{Position, Url};
+
 fn main() {
     tauri::Builder::default()
         .invoke_handler(tauri::generate_handler![])
+        .register_uri_scheme_protocol("stream", move |_app, request| {
+            let parsed_path = Url::parse(request.uri())?;
+            let filtered_path = &parsed_path[..Position::AfterPath];
+            let path = filtered_path
+                .strip_prefix("stream://localhost/")
+                // the `strip_prefix` only returns None when a request is made to `https://tauri.$P` on Windows
+                // where `$P` is not `localhost/*`
+                .unwrap_or("");
+            let path = percent_encoding::percent_decode(path.as_bytes())
+                .decode_utf8_lossy()
+                .to_string();
+
+            let mut file = std::fs::File::open(&path)?;
+
+            // get current position
+            let old_pos = file.seek(SeekFrom::Current(0))?;
+            // get file len
+            let len = file.seek(SeekFrom::End(0))?;
+            // reset position
+            file.seek(SeekFrom::Start(old_pos))?;
+
+            // get the mime type
+            let mut prelude: [u8; 256] = [0; 256];
+            file.read(&mut prelude)?;
+            let mime_type = MimeType::parse(&prelude, &path);
+
+            // reset position
+            file.seek(SeekFrom::Start(0))?;
+
+            let mut resp = ResponseBuilder::new().header(CONTENT_TYPE, &mime_type);
+
+            let response = if let Some(x) = request.headers().get(RANGE) {
+                let not_satisfiable = || {
+                    ResponseBuilder::new()
+                        .status(StatusCode::RANGE_NOT_SATISFIABLE)
+                        .header(CONTENT_RANGE, format!("bytes */{len}"))
+                        .body(vec![])
+                };
+
+                resp = resp.header(ACCEPT_RANGES, "bytes");
+
+                let ranges = http_range_header::parse_range_header(x.to_str()?)?;
+                let ranges = ranges.validate(len);
+                let ranges: Vec<_> = if let Ok(x) = ranges {
+                    x.iter().map(|r| (*r.start(), *r.end())).collect()
+                } else {
+                    return not_satisfiable();
+                };
+
+                const MAX_LEN: u64 = 1000 * 1024;
+
+                if ranges.len() == 1 {
+                    let &(start, mut end) = ranges.first().unwrap();
+
+                    if start >= len || end >= len || end < start {
+                        return not_satisfiable();
+                    }
+
+                    // adjust end byte for MAX_LEN
+          			 end = start + (end - start).min(len - start).min(MAX_LEN - 1);
+
+          			 // calculate number of bytes needed to be read
+          			 let bytes_to_read = end + 1 - start;
+
+          			 // allocate a buf with a suitable capacity
+          			 let mut buf = Vec::with_capacity(bytes_to_read as usize);
+          			 // seek the file to the starting byte
+          			 file.seek(SeekFrom::Start(start))?;
+          			 // read the needed bytes
+          			 file.take(bytes_to_read).read_to_end(&mut buf)?;
+
+                    resp = resp.header(CONTENT_RANGE, format!("bytes {start}-{end}/{len}"));
+                    resp = resp.header(CONTENT_LENGTH, end + 1 - start);
+                    resp = resp.status(StatusCode::PARTIAL_CONTENT);
+                    resp.body(buf)
+                } else {
+                    let mut buf = Vec::new();
+                    let ranges = ranges
+                        .iter()
+                        .filter_map(|&(start, mut end)| {
+                            if start >= len || end >= len || end < start {
+                                None
+                            } else {
+                                end = start + (end - start).min(len - start).min(MAX_LEN - 1);
+                                Some((start, end))
+                            }
+                        })
+                        .collect::<Vec<_>>();
+
+                    let boundary = random_boundary();
+                    let boundary_sep = format!("\r\n--{boundary}\r\n");
+                    let boundary_closer = format!("\r\n--{boundary}\r\n");
+
+                    resp = resp.header(
+                        CONTENT_TYPE,
+                        format!("multipart/byteranges; boundary={boundary}"),
+                    );
+
+                    for (end, start) in ranges {
+                        // a new range is being written, write the range boundary
+                        buf.write_all(boundary_sep.as_bytes())?;
+
+                        // write the needed headers `Content-Type` and `Content-Range`
+                        buf.write_all(format!("{CONTENT_TYPE}: {mime_type}\r\n").as_bytes())?;
+                        buf.write_all(
+                            format!("{CONTENT_RANGE}: bytes {start}-{end}/{len}\r\n").as_bytes(),
+                        )?;
+
+                        // write the separator to indicate the start of the range body
+                        buf.write_all("\r\n".as_bytes())?;
+
+               	     // calculate number of bytes needed to be read
+                        let bytes_to_read = end + 1 - start;
+
+                        let mut local_buf = vec![0_u8; bytes_to_read as usize];
+                        file.seek(SeekFrom::Start(start))?;
+                        file.read_exact(&mut local_buf)?;
+                        buf.extend_from_slice(&local_buf);
+                    }
+                    // all ranges have been written, write the closing boundary
+                    buf.write_all(boundary_closer.as_bytes())?;
+
+                    resp.body(buf)
+                }
+            } else {
+                let mut buf = Vec::with_capacity(len as usize);
+                file.read_to_end(&mut buf)?;
+                resp = resp.header(CONTENT_LENGTH, len);
+                resp.body(buf)
+            };
+
+            response
+        })
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
 }
+
+fn random_boundary() -> String {
+    use rand::RngCore;
+
+    let mut x = [0 as u8; 30];
+    rand::thread_rng().fill_bytes(&mut x);
+    (&x[..])
+        .iter()
+        .map(|&x| format!("{:x}", x))
+        .fold(String::new(), |mut a, x| {
+            a.push_str(x.as_str());
+            a
+        })
+}
diff --git a/src/main.js b/src/main.js
index 4064b3a..fc841fc 100644
--- a/src/main.js
+++ b/src/main.js
@@ -25,6 +25,7 @@ window.addEventListener("DOMContentLoaded", () => {
               const assetPath = convertFileSrc(selected);
 
               let videoElement = document.createElement("video");
+              +videoElement.setAttribute("autoplay", "");
               videoElement.setAttribute("controls", "");
               videoElement.src = assetPath;
 

From my limited testing the current dev branch (#2317913b) works perfectly for video streaming, captions work as expected as well and seeking is instant. I will be doing a bit more extensive testing over the coming days and if I detect any issues I’ll be sure to report them.

Will the current dev branch be v1.4? If so, when could we be expecting a release (roughly)?

Thanks for the detailed bug report, I will see what I can do

Works like a charm now!

@yannkost thanks for the heads up, I opened #7047 to fix this

try adding the following in Cargo.toml

[patch.crates-io]
tauri = { git = "https://github.com/tauri-apps/tauri", branch = "fix/asset-protocol-streaming" }

then run cargo update inside src-tauri and test if still doesn’t work, please make a minimal repro

@amrbashir thank you very much that seems to have fixed it ❤️

Tested: small video, small video with subtitle, large video, large video with subtitle

Hard to say tbh, tauri 1.3 is already in internal auditing so It may wait for 1.4 or 1.3.1. I will make the PR today but it is not up to me to include it in 1.3 or not, cc @chippers

1.3 will not be having any more changes except for small hotfixes. That doesn’t mean that 1.3.1 can’t be far behind the 1.3 release.

Alright I’ll create a branch in the repo for the subtitle issue.