Youtube: attempt to auto-detect throttling and restart download

1 files changed, 17 insertions, 31 deletions

diff --git a/src/QuickMedia.cpp b/src/QuickMedia.cpp
index 2db5537..bb92484 100644
--- a/src/QuickMedia.cpp
+++ b/src/QuickMedia.cpp
@@ -2550,9 +2550,6 @@ namespace QuickMedia {
         PageType previous_page = pop_page_stack();
 
         bool video_loaded = false;
-        bool in_seeking = false;
-        sf::Clock seeking_start_timer;
-        const float seeking_restart_timeout_sec = 10.0f; // TODO: Test if this timeout is good on slow hardware such as pinephone and slow internet
 
         std::string youtube_video_id_dummy;
         const bool is_youtube = youtube_url_extract_id(video_page->get_url(), youtube_video_id_dummy);
@@ -2569,7 +2566,7 @@ namespace QuickMedia {
         }
 
         sf::WindowHandle video_player_window = None;
-        auto on_window_create = [this, &video_player_window, &video_loaded, &in_seeking](sf::WindowHandle _video_player_window) mutable {
+        auto on_window_create = [this, &video_player_window, &video_loaded](sf::WindowHandle _video_player_window) mutable {
             video_player_window = _video_player_window;
             XSelectInput(disp, video_player_window, KeyPressMask | PointerMotionMask);
             XSync(disp, False);
@@ -2578,10 +2575,8 @@ namespace QuickMedia {
             // TODO: This is an issue just because of ubuntu shit that uses old mpv that doesn't support ipc over file descriptors.
             double time_in_file = 0.0;
             video_player->get_time_in_file(&time_in_file);
-            if(time_in_file > 0.00001) {
+            if(time_in_file > 0.00001)
                 video_loaded = true;
-                in_seeking = false;
-            }
         };
 
         std::unique_ptr<YoutubeMediaProxy> youtube_video_media_proxy;
@@ -2602,11 +2597,15 @@ namespace QuickMedia {
         std::string prev_start_time;
         std::vector<MediaChapter> media_chapters;
 
-        auto load_video_error_check = [this, &youtube_downloader_task, &youtube_video_media_proxy, &youtube_audio_media_proxy, &youtube_video_content_length, &youtube_audio_content_length, &prev_start_time, &media_chapters, &in_seeking, &video_url, &audio_url, &has_embedded_audio, &video_title, &video_tasks, &channel_url, previous_page, &go_to_previous_page, &video_loaded, video_page, &video_event_callback, &on_window_create, &video_player_window, is_youtube, is_matrix, download_if_streaming_fails](std::string start_time = "", bool reuse_media_source = false) mutable {
+        bool throttled = false;
+        auto throttle_handler = [&throttled] {
+            throttled = true;
+        };
+
+        auto load_video_error_check = [this, &throttle_handler, &throttled, &youtube_downloader_task, &youtube_video_media_proxy, &youtube_audio_media_proxy, &youtube_video_content_length, &youtube_audio_content_length, &prev_start_time, &media_chapters, &video_url, &audio_url, &has_embedded_audio, &video_title, &video_tasks, &channel_url, previous_page, &go_to_previous_page, &video_loaded, video_page, &video_event_callback, &on_window_create, &video_player_window, is_youtube, is_matrix, download_if_streaming_fails](std::string start_time = "", bool reuse_media_source = false) mutable {
             video_player.reset();
             channel_url.clear();
             video_loaded = false;
-            in_seeking = false;
             video_player_window = None;
 
             bool is_audio_only = no_video;
@@ -2713,6 +2712,7 @@ namespace QuickMedia {
                 youtube_downloader_task.cancel();
                 youtube_video_media_proxy.reset();
                 youtube_audio_media_proxy.reset();
+                throttled = false;
 
                 struct MediaProxyMetadata {
                     std::unique_ptr<YoutubeMediaProxy> *media_proxy;
@@ -2729,7 +2729,7 @@ namespace QuickMedia {
                     if(media_proxies[i].url->empty() || youtube_url_is_live_stream(*media_proxies[i].url))
                         continue;
 
-                    *media_proxies[i].media_proxy = std::make_unique<YoutubeStaticMediaProxy>();
+                    *media_proxies[i].media_proxy = std::make_unique<YoutubeStaticMediaProxy>(throttle_handler);
                     if(!(*media_proxies[i].media_proxy)->start(*media_proxies[i].url, media_proxies[i].content_length)) {
                         show_notification("QuickMedia", "Failed to load start youtube media proxy", Urgency::CRITICAL);
                         current_page = previous_page;
@@ -2823,27 +2823,17 @@ namespace QuickMedia {
             }
         };
 
-        video_event_callback = [&video_loaded, &in_seeking, &seeking_start_timer](const char *event_name) mutable {
-            if(strcmp(event_name, "seek") == 0) {
-                in_seeking = true;
-                seeking_start_timer.restart();
-            }
-
+        video_event_callback = [&video_loaded](const char *event_name) mutable {
             if(strcmp(event_name, "pause") == 0) {
                 //double time_remaining = 9999.0;
                 //if(video_player->get_time_remaining(&time_remaining) == VideoPlayer::Error::OK && time_remaining <= 1.0)
                 //    end_of_file = true;
             } else if(strcmp(event_name, "playback-restart") == 0) {
                 //video_player->set_paused(false);
-                in_seeking = false;
             } else if(strcmp(event_name, "file-loaded") == 0) {
                 video_loaded = true;
-                in_seeking = false;
             } else if(strcmp(event_name, "video-reconfig") == 0 || strcmp(event_name, "audio-reconfig") == 0) {
-                if(!video_loaded) {
-                    video_loaded = true;
-                }
-                in_seeking = false;
+                video_loaded = true;
             }
 
             //fprintf(stderr, "event name: %s\n", event_name);
@@ -2918,7 +2908,6 @@ namespace QuickMedia {
                 } else if(pressed_keysym == XK_s && pressing_ctrl) {
                     video_page_download_video(video_page->get_url(), video_player_window);
                 } else if(pressed_keysym == XK_F5) {
-                    in_seeking = false;
                     double resume_start_time = 0.0;
                     video_player->get_time_in_file(&resume_start_time);
                     load_video_error_check(std::to_string((int)resume_start_time));
@@ -3017,15 +3006,12 @@ namespace QuickMedia {
                 cursor_visible = true;
             }
 
-            // TODO: Remove the need for this. This is needed right now because mpv sometimes gets stuck when playing youtube videos after seeking too much
-            if(is_youtube && video_player && in_seeking && seeking_start_timer.getElapsedTime().asSeconds() >= seeking_restart_timeout_sec) {
-                in_seeking = false;
+            if(is_youtube && video_player && throttled) {
+                throttled = false;
+                fprintf(stderr, "Throttled media download detected, reconnecting...\n");
                 double resume_start_time = 0.0;
-                if(video_player->get_time_in_file(&resume_start_time) == VideoPlayer::Error::OK) {
-                    fprintf(stderr, "Video seems to be stuck after seeking, reloading...\n");
-                    // TODO: Set the second argument to false if the video url is no longer valid (or always?)
-                    load_video_error_check(std::to_string((int)resume_start_time), true);
-                }
+                video_player->get_time_in_file(&resume_start_time);
+                load_video_error_check(std::to_string((int)resume_start_time));
             }
 
             VideoPlayer::Error update_err = video_player ? video_player->update() : VideoPlayer::Error::OK;