Rework youtube redirect code

1 files changed, 57 insertions, 79 deletions

diff --git a/src/QuickMedia.cpp b/src/QuickMedia.cpp
index e6e4719..97900d3 100644
--- a/src/QuickMedia.cpp
+++ b/src/QuickMedia.cpp
@@ -2532,8 +2532,6 @@ namespace QuickMedia {
         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
 
-        const int num_load_tries_max = 3;
-        int load_try = 0;
         std::string prev_start_time;
         std::vector<MediaChapter> media_chapters;
 
@@ -2553,73 +2551,70 @@ namespace QuickMedia {
                 audio_url.clear();
                 has_embedded_audio = true;
 
-                TaskResult load_result = run_task_with_loading_screen([this, video_page, &youtube_video_content_length, &youtube_audio_content_length, &new_title, &channel_url, &media_chapters, largest_monitor_height, &has_embedded_audio, &video_url, &audio_url, &is_audio_only, &previous_page, is_youtube, download_if_streaming_fails]() {
-                    if(video_page->load(new_title, channel_url, media_chapters) != PluginResult::OK)
-                        return false;
-
-                    if(!no_video)
-                        video_url = video_page->get_video_url(largest_monitor_height, has_embedded_audio);
-
-                    if(video_url.empty() || no_video) {
-                        video_url = video_page->get_audio_url();
-                        if(video_url.empty()) {
-                            video_url = video_page->get_url();
-                            has_embedded_audio = true;
-                        } else {
-                            is_audio_only = true;
-                            has_embedded_audio = false;
-                        }
-                    } else if(!has_embedded_audio) {
-                        audio_url = video_page->get_audio_url();
-                    }
-
-                    if(!is_youtube && download_if_streaming_fails) {
-                        if(!video_download_if_non_streamable(video_url, audio_url, is_audio_only, has_embedded_audio, previous_page))
+                const int num_retries = is_youtube ? 3 : 1;
+                bool load_successful = false;
+                for(int i = 0; i < num_retries; ++i) {
+                    bool cancelled = false;
+                    TaskResult load_result = run_task_with_loading_screen([this, video_page, &cancelled, &new_title, &channel_url, &media_chapters, &youtube_video_content_length, &youtube_audio_content_length, largest_monitor_height, &has_embedded_audio, &video_url, &audio_url, &is_audio_only, &previous_page, is_youtube, download_if_streaming_fails]() {
+                        if(video_page->load(new_title, channel_url, media_chapters) != PluginResult::OK)
                             return false;
-                    }
 
-                    if(is_youtube) {
-                        // TODO: Do these requests in parallel
-                        std::pair<std::string*, int*> media_url_content_lengths[2] = {
-                            std::make_pair(&video_url, &youtube_video_content_length),
-                            std::make_pair(&audio_url, &youtube_audio_content_length),
-                        };
-                        for(int i = 0; i < 2; ++i) {
-                            if(media_url_content_lengths[i].first->empty() || youtube_url_is_live_stream(*media_url_content_lengths[i].first)) {
-                                *media_url_content_lengths[i].second = 0;
-                                continue;
-                            }
+                        if(!no_video)
+                            video_url = video_page->get_video_url(largest_monitor_height, has_embedded_audio);
 
-                            std::string headers;
-                            if(download_head_to_string(*media_url_content_lengths[i].first, headers) != DownloadResult::OK)
-                                return false;
+                        if(video_url.empty() || no_video) {
+                            video_url = video_page->get_audio_url();
+                            if(video_url.empty()) {
+                                video_url = video_page->get_url();
+                                has_embedded_audio = true;
+                            } else {
+                                is_audio_only = true;
+                                has_embedded_audio = false;
+                            }
+                        } else if(!has_embedded_audio) {
+                            audio_url = video_page->get_audio_url();
+                        }
 
-                            std::string content_length = header_extract_value(headers, "content-length");
-                            if(content_length.empty())
+                        if(!is_youtube && download_if_streaming_fails) {
+                            if(!video_download_if_non_streamable(video_url, audio_url, is_audio_only, has_embedded_audio, previous_page))
                                 return false;
+                        }
 
-                            errno = 0;
-                            char *endptr;
-                            const long content_length_tmp = strtol(content_length.c_str(), &endptr, 10);
-                            if(endptr != content_length.c_str() && errno == 0) {
-                                *media_url_content_lengths[i].second = content_length_tmp;
-                            } else {
+                        if(is_youtube && !youtube_url_is_live_stream(video_url) && !youtube_url_is_live_stream(audio_url)) {
+                            youtube_video_content_length = 0;
+                            youtube_audio_content_length = 0;
+                            std::string new_video_url = video_url;
+                            std::string new_audio_url = audio_url;
+                            auto current_thread_id = std::this_thread::get_id();
+                            if(!youtube_custom_redirect(new_video_url, new_audio_url, youtube_video_content_length, youtube_audio_content_length, [current_thread_id]{ return !program_is_dead_in_thread(current_thread_id); })) {
+                                if(program_is_dead_in_current_thread())
+                                    cancelled = true;
                                 return false;
                             }
+
+                            video_url = std::move(new_video_url);
+                            audio_url = std::move(new_audio_url);
                         }
-                    }
 
-                    return true;
-                });
+                        return true;
+                    });
 
-                if(!new_title.empty())
-                    video_title = std::move(new_title);
+                    if(!new_title.empty())
+                        video_title = std::move(new_title);
 
-                if(load_result == TaskResult::CANCEL) {
-                    current_page = previous_page;
-                    go_to_previous_page = true;
-                    return;
-                } else if(load_result == TaskResult::FALSE) {
+                    if(load_result == TaskResult::CANCEL || cancelled) {
+                        current_page = previous_page;
+                        go_to_previous_page = true;
+                        return;
+                    } else if(load_result == TaskResult::FALSE) {
+                        continue;
+                    }
+
+                    load_successful = true;
+                    break;
+                }
+
+                if(!load_successful) {
                     show_notification("QuickMedia", "Failed to load media", Urgency::CRITICAL);
                     current_page = previous_page;
                     go_to_previous_page = true;
@@ -2762,7 +2757,7 @@ namespace QuickMedia {
             }
         };
 
-        video_event_callback = [&load_try, &video_loaded, &in_seeking, &seeking_start_timer](const char *event_name) mutable {
+        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();
@@ -2775,17 +2770,14 @@ namespace QuickMedia {
             } else if(strcmp(event_name, "playback-restart") == 0) {
                 //video_player->set_paused(false);
                 in_seeking = false;
-                load_try = 0;
             } else if(strcmp(event_name, "file-loaded") == 0) {
                 video_loaded = true;
                 in_seeking = false;
-                load_try = 0;
             } else if(strcmp(event_name, "video-reconfig") == 0 || strcmp(event_name, "audio-reconfig") == 0) {
                 if(!video_loaded) {
                     video_loaded = true;
                 }
                 in_seeking = false;
-                load_try = 0;
             }
 
             //fprintf(stderr, "event name: %s\n", event_name);
@@ -3064,24 +3056,10 @@ namespace QuickMedia {
 
                 load_video_error_check();
             } else if(update_err != VideoPlayer::Error::OK) {
-                ++load_try;
-                if(load_try == 1 && num_load_tries_max > 1 && is_youtube) {
-                    fprintf(stderr, "Failed to play the media, retrying (try %d out of %d)\n", 1 + load_try, num_load_tries_max);
-                    std::string prev_video_url = video_url;
-                    std::string prev_audio_url = audio_url;
-                    youtube_custom_redirect(video_url, audio_url);
-                    load_video_error_check(prev_start_time, video_url != prev_video_url || audio_url != prev_audio_url);
-                } else {
-                    if(load_try < num_load_tries_max) {
-                        fprintf(stderr, "Failed to play the media, retrying (try %d out of %d)\n", 1 + load_try, num_load_tries_max);
-                        load_video_error_check(prev_start_time);
-                    } else {
-                        show_notification("QuickMedia", "Failed to play the video (error code " + std::to_string((int)update_err) + ")", Urgency::CRITICAL);
-                        current_page = previous_page;
-                        go_to_previous_page = true;
-                        break;
-                    }
-                }
+                show_notification("QuickMedia", "Failed to play the video (error code " + std::to_string((int)update_err) + ")", Urgency::CRITICAL);
+                current_page = previous_page;
+                go_to_previous_page = true;
+                break;
             }
 
             AsyncImageLoader::get_instance().update();