Greasy Fork is available in English.
为各类网站视频提供通用的倍速播放控制功能
// ==UserScript==
// @name 通用视频倍速播放控制
// @namespace http://tampermonkey.net/
// @version 3.5
// @description 为各类网站视频提供通用的倍速播放控制功能
// @author ming2k
// @match https://www.bilibili.com/video/*
// @match https://www.youtube.com/*
// @match https://www.iyf.tv/play/*
// @grant none
// @run-at document-idle
// @license MIT
// ==/UserScript==
(function() {
'use strict';
// 配置信息 - 针对慢加载视频优化
const config = {
// 默认初始播放速度
defaultSpeed: 1.0,
// 变速步长
speedStep: 0.1,
// 最小速度
minSpeed: 0.1,
// 最大速度
maxSpeed: 4.0,
// 提示显示时间(毫秒)
notificationDuration: 1500,
// 快捷键设置（与MPV兼容）
hotkeys: {
increaseSpeed: ']', // 增加速度
decreaseSpeed: '[', // 减少速度
resetSpeed: '{', // 重置速度
doubleSpeed: '}' // 2倍速
},
// 启用详细日志
debug: true,
// 尝试间隔(毫秒) - 增加间隔以处理慢速加载
retryInterval: 2000,
// 最大尝试次数 - 大幅增加以处理慢速加载
maxRetries: 40,
// 延长初始等待时间(毫秒)
initialWaitTime: 5000,
// 长时间监控 - 持续时间(毫秒)
longTermMonitoring: 300000, // 5分钟
// 长时间监控 - 检查间隔(毫秒)
longTermCheckInterval: 8000
};
// 状态变量
let videoElement = null;
let retryCount = 0;
let notificationTimer = null;
let notification = null;
// 统一的存储键名
const storageKey = 'video_playback_speed';
let lastStoredSpeed = parseFloat(localStorage.getItem(storageKey)) || config.defaultSpeed;
let isInitialized = false;
let videoObserver = null;
let speedApplied = false;
let currentVideoUrl = location.href; // 记录当前视频URL
let longTermMonitoringTimer = null;
let videoFoundTime = null;
let pendingSpeedPromise = null;
let waitingForVideo = false;
// 日志函数
function log(message, force = false) {
if (config.debug || force) {
console.log(`[视频倍速控制] ${message}`);
}
}
// 添加样式
function addStyles() {
const styles = `
.speed-notification {
position: fixed;
top: 70px;
left: 50%;
transform: translateX(-50%);
background-color: rgba(0, 0, 0, 0.8);
color: white;
padding: 10px 20px;
border-radius: 4px;
z-index: 9999999;
font-size: 16px;
font-weight: bold;
opacity: 0;
transition: opacity 0.3s ease;
box-shadow: 0 3px 6px rgba(0, 0, 0, 0.16);
text-align: center;
pointer-events: none;
}
.speed-notification.show {
opacity: 1;
}
`;
const styleElement = document.createElement('style');
styleElement.textContent = styles;
document.head.appendChild(styleElement);
log('样式已添加');
}
// 创建通知元素
function createNotification() {
notification = document.createElement('div');
notification.className = 'speed-notification';
document.body.appendChild(notification);
log('通知元素已创建');
}
// 显示通知
function showNotification(message) {
if (!notification) {
createNotification();
}
notification.textContent = message;
notification.classList.add('show');
// 清除之前的定时器
if (notificationTimer) {
clearTimeout(notificationTimer);
}
// 设置新定时器隐藏通知
notificationTimer = setTimeout(() => {
notification.classList.remove('show');
}, config.notificationDuration);
}
// 检查视频是否可用函数 - 更严格的可用性检查
function isVideoPlayable(video) {
if (!video) return false;
try {
// 检查视频是否有效
if (video.readyState === 0) {
log('视频元素存在但尚未初始化 (readyState=0)');
return false;
}
// 检查视频是否有效源或内容
const hasSource = video.src ||
video.querySelector('source') ||
video.readyState > 0;
// 检查视频是否在文档中
const isInDocument = document.contains(video);
// 检查视频是否有尺寸
const hasDimensions = (video.videoWidth > 0 && video.videoHeight > 0) ||
(video.offsetWidth > 0 && video.offsetHeight > 0);
// 基本检查
if (!hasSource) {
log('视频元素没有有效源');
return false;
}
if (!isInDocument) {
log('视频元素不在文档中');
return false;
}
// 额外检查 - 可选
if (!hasDimensions && video.readyState <= 1) {
log('视频元素没有尺寸且readyState低');
// 注意：某些网站可能隐藏了视频尺寸，所以这不是硬性条件
// 如果视频的readyState > 1，我们认为它是可用的，即使没有尺寸
if (video.readyState <= 1) {
return false;
}
}
return true;
} catch (e) {
log(`检查视频可用性时出错: ${e.message}`);
return false;
}
}
// 增强版查找视频元素
function findVideoElement() {
// 检查现有的视频元素是否仍然有效
if (videoElement && isVideoPlayable(videoElement)) {
return videoElement;
}
log('开始查找视频元素...');
// 尝试多种选择器
const selectors = [
'video', // 标准视频标签
'.video-container video', // 从HTML结构分析得出的可能选择器
'.video-box video', // 另一个可能的选择器
'vg-player video', // Videogular
'aa-videoplayer video', // 自定义播放器
'*[id*="player"] video', // ID中包含player的元素内的视频
'*[class*="player"] video', // class中包含player的元素内的视频
// 增加更多选择器用于慢加载网站
'*[id*="video"] video', // ID中包含video的元素
'*[class*="video"] video', // class中包含video的元素
'iframe[src*="player"] video', // iframe中的播放器视频
'video[preload]', // 预加载的视频
'.container video', // 常见容器内的视频
'main video', // 主内容区域的视频
'article video', // 文章内的视频
'div > video', // div直接子元素的视频
'video[src]', // 有src属性的视频
'video > source', // 有source子元素的视频
];
let foundVideos = [];
// 收集所有视频元素
for (const selector of selectors) {
const elements = document.querySelectorAll(selector);
if (elements && elements.length > 0) {
for (const video of elements) {
// 获取实际视频元素（可能是source的父元素）
const actualVideo = video.tagName.toLowerCase() === 'video' ? video : video.closest('video');
if (actualVideo && !foundVideos.includes(actualVideo) && isVideoPlayable(actualVideo)) {
foundVideos.push(actualVideo);
log(`找到可能的视频元素: ${selector}`);
}
}
}
}
// 如果找到多个视频，尝试找出主视频
if (foundVideos.length > 1) {
log(`找到${foundVideos.length}个视频元素，尝试确定主视频`);
// 按照可能性排序：
// 1. 可见的
// 2. 更大的
// 3. 位于视口中的
foundVideos.sort((a, b) => {
const aVisible = isElementVisible(a);
const bVisible = isElementVisible(b);
// 可见性优先
if (aVisible && !bVisible) return -1;
if (!aVisible && bVisible) return 1;
// 然后是尺寸
const aSize = (a.offsetWidth || 0) * (a.offsetHeight || 0);
const bSize = (b.offsetWidth || 0) * (b.offsetHeight || 0);
if (aSize > bSize) return -1;
if (aSize < bSize) return 1;
// 最后是视口中的位置
const aInViewport = isInViewport(a);
const bInViewport = isInViewport(b);
if (aInViewport && !bInViewport) return -1;
if (!aInViewport && bInViewport) return 1;
return 0;
});
log(`选择最可能的主视频元素`);
return foundVideos[0];
} else if (foundVideos.length === 1) {
return foundVideos[0];
}
// 尝试搜索所有iframe
const iframes = document.querySelectorAll('iframe');
for (let iframe of iframes) {
try {
if (iframe.contentDocument) {
const iframeVideo = iframe.contentDocument.querySelector('video');
if (iframeVideo && isVideoPlayable(iframeVideo)) {
log('在iframe中找到视频');
return iframeVideo;
}
}
} catch (e) {
// 跨域iframe无法访问内容
log('无法访问iframe内容: ' + e.message);
}
}
// 深度搜索
function deepSearch(element, depth = 0) {
if (!element || depth > 15) return null; // 增加搜索深度
if (element.tagName && element.tagName.toLowerCase() === 'video' && isVideoPlayable(element)) {
return element;
}
// 搜索shadowDOM
if (element.shadowRoot) {
const shadowVideo = element.shadowRoot.querySelector('video');
if (shadowVideo && isVideoPlayable(shadowVideo)) return shadowVideo;
// 深度搜索shadowDOM
const allShadowElements = element.shadowRoot.querySelectorAll('*');
for (const shadowEl of allShadowElements) {
const found = deepSearch(shadowEl, depth + 1);
if (found) return found;
}
}
for (let i = 0; i < element.children.length; i++) {
const found = deepSearch(element.children[i], depth + 1);
if (found) return found;
}
return null;
}
const deepSearchResult = deepSearch(document.body);
if (deepSearchResult) {
log('通过深度搜索找到视频');
return deepSearchResult;
}
// 最后尝试通过动态加载的iframe查找
// 某些网站可能延迟加载包含视频的iframe
try {
// 查找所有iframe，包括新加载的
const allIframes = document.querySelectorAll('iframe');
for (const iframe of allIframes) {
try {
// 尝试判断iframe是否是视频播放器
const isVideoFrame = iframe.src.includes('player') ||
iframe.src.includes('video') ||
iframe.src.includes('embed') ||
iframe.id.includes('player') ||
iframe.className.includes('player');
if (isVideoFrame) {
log('找到可能包含视频的iframe，但无法直接访问内容');
// 不能直接返回iframe，但可以记录它存在
// 一些网站可能需要特殊处理
}
} catch (e) {
// 忽略跨域错误
}
}
} catch (e) {
log(`检查iframe时出错: ${e.message}`);
}
log('未找到视频元素');
return null;
}
// 检查元素是否可见
function isElementVisible(element) {
if (!element) return false;
const style = window.getComputedStyle(element);
return style.display !== 'none' &&
style.visibility !== 'hidden' &&
style.opacity !== '0' &&
element.offsetWidth > 0 &&
element.offsetHeight > 0;
}
// 检查元素是否在视口中
function isInViewport(element) {
if (!element) return false;
const rect = element.getBoundingClientRect();
return (
rect.top >= 0 &&
rect.left >= 0 &&
rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) &&
rect.right <= (window.innerWidth || document.documentElement.clientWidth)
);
}
// 获取最后使用的速度
function getLastSpeed() {
try {
const savedSpeed = parseFloat(localStorage.getItem(storageKey));
if (!isNaN(savedSpeed) && savedSpeed > 0) {
log(`从localStorage加载速度: ${savedSpeed}x`);
return savedSpeed;
}
} catch (e) {
log(`无法读取保存的速度: ${e.message}`);
}
log(`未找到保存的速度，使用默认速度 ${config.defaultSpeed}x`);
return config.defaultSpeed;
}
// 保存最后使用的速度
function saveLastSpeed(speed) {
lastStoredSpeed = speed;
try {
localStorage.setItem(storageKey, speed);
log(`已保存播放速度 ${speed}x 到localStorage`);
} catch (e) {
log(`无法保存速度: ${e.message}`);
}
}
// 尝试多种方法设置播放速度 - 添加承诺等待功能
function setPlaybackSpeed(speed, showNotifFlag = true) {
// 确保速度在范围内
speed = Math.max(config.minSpeed, Math.min(config.maxSpeed, speed));
speed = parseFloat(speed.toFixed(1)); // 保留一位小数
// 如果已经有等待设置的承诺，则取消它
if (pendingSpeedPromise) {
clearTimeout(pendingSpeedPromise);
pendingSpeedPromise = null;
}
// 查找视频元素
const video = findVideoElement();
if (video) {
try {
video.playbackRate = speed;
log(`使用标准方式设置速度: ${speed}x`);
if (showNotifFlag) {
showNotification(`播放速度: ${speed}x`);
}
saveLastSpeed(speed);
return true;
} catch (e) {
log(`标准方式设置速度失败: ${e.message}`);
}
} else {
// 如果没找到视频但脚本已运行一段时间，设置一个延迟尝试
log(`未找到视频元素，设置延迟尝试设置速度: ${speed}x`);
waitingForVideo = true;
pendingSpeedPromise = setTimeout(() => {
log(`执行延迟设置速度: ${speed}x`);
setPlaybackSpeed(speed, showNotifFlag);
pendingSpeedPromise = null;
}, 5000);
// 返回false表示当前未成功设置
return false;
}
// 尝试使用JavaScript注入
try {
const script = document.createElement('script');
script.textContent = `
(function() {
try {
const videos = document.querySelectorAll('video');
let success = false;
if (videos.length > 0) {
videos.forEach(v => {
try {
// 检查视频是否有效
if (v && !v.ended && v.readyState > 0) {
v.playbackRate = ${speed};
success = true;
}
} catch(e) {
console.error('无法设置视频速度:', e);
}
});
}
// 尝试从全局变量中找到播放器
const playerVars = ['player', 'videoPlayer', 'vgPlayer', 'mediaPlayer', 'ytPlayer', 'videojs'];
for (const varName of playerVars) {
if (window[varName]) {
// 尝试不同的方法设置速度
try {
if (typeof window[varName].setPlaybackRate === 'function') {
window[varName].setPlaybackRate(${speed});
success = true;
} else if (window[varName].player && typeof window[varName].player.setPlaybackRate === 'function') {
window[varName].player.setPlaybackRate(${speed});
success = true;
} else if (window[varName].getMedia && window[varName].getMedia()) {
window[varName].getMedia().playbackRate = ${speed};
success = true;
} else if (window[varName].video && window[varName].video.playbackRate !== undefined) {
window[varName].video.playbackRate = ${speed};
success = true;
} else if (window[varName].el && window[varName].el.playbackRate !== undefined) {
window[varName].el.playbackRate = ${speed};
success = true;
}
} catch(e) {
console.error('尝试通过全局变量设置速度失败:', e);
}
}
}
// 尝试在Angular组件中查找
if (window.ng && window.ng.probe) {
const playerElements = document.querySelectorAll('vg-player, [class*="player"]');
playerElements.forEach(el => {
try {
const componentInstance = window.ng.probe(el);
if (componentInstance && componentInstance.componentInstance) {
const instance = componentInstance.componentInstance;
if (instance.media && instance.media.playbackRate !== undefined) {
instance.media.playbackRate = ${speed};
success = true;
}
}
} catch(e) {}
});
}
// 尝试特定网站API
// YouTube
if (typeof document.querySelector('.html5-video-player') !== 'undefined') {
const ytPlayer = document.querySelector('.html5-video-player');
if (ytPlayer && ytPlayer.getPlayer) {
try {
ytPlayer.getPlayer().setPlaybackRate(${speed});
success = true;
} catch(e) {}
}
}
// HTML5 video API - 再次尝试
document.querySelectorAll('video').forEach(v => {
if (v && v.readyState > 0) {
try {
v.playbackRate = ${speed};
success = true;
} catch(e) {}
}
});
window._speedChangeSuccess = success;
} catch(e) {
console.error('播放速度注入脚本错误:', e);
window._speedChangeSuccess = false;
}
})();
`;
document.body.appendChild(script);
document.body.removeChild(script);
// 检查是否成功
if (window._speedChangeSuccess) {
log(`通过脚本注入设置速度: ${speed}x`);
if (showNotifFlag) {
showNotification(`播放速度: ${speed}x`);
}
saveLastSpeed(speed);
return true;
}
} catch (e) {
log(`脚本注入设置失败: ${e.message}`);
}
if (showNotifFlag) {
log('无法设置播放速度，将在视频加载后重试', true);
showNotification(`已保存速度设置，等待视频加载...`);
// 保存要设置的速度，以便在视频加载后应用
saveLastSpeed(speed);
}
return false;
}
// 修改播放速度
function changeSpeed(delta) {
const video = findVideoElement();
const currentSpeed = video ? video.playbackRate : lastStoredSpeed;
const newSpeed = Math.round((currentSpeed + delta) * 10) / 10; // 保留一位小数
if (setPlaybackSpeed(newSpeed)) {
lastStoredSpeed = newSpeed; // 确保当前调整的速度被记录为"最后一次速度"
} else {
// 如果设置失败但视频尚未加载，仍保存速度以便之后应用
lastStoredSpeed = newSpeed;
saveLastSpeed(newSpeed);
}
}
// 播放速度控制相关函数
function resetSpeed() {
setPlaybackSpeed(config.defaultSpeed);
}
function doubleSpeed() {
setPlaybackSpeed(2.0);
}
// 改进版：只处理特定按键的冲突而不是禁用所有键盘事件
function handleConflictingKeyBindings() {
// 创建包含我们需要拦截的按键数组
const ourHotkeys = Object.values(config.hotkeys);
log(`我们的热键: ${ourHotkeys.join(', ')}`);
// 替代注入脚本，只阻止特定按键的事件
const script = document.createElement('script');
script.textContent = `
(function() {
try {
// 获取我们需要处理的快捷键
const keysToCatch = ${JSON.stringify(ourHotkeys)};
// 创建更精确的事件监听器，在捕获阶段先拦截
document.addEventListener('keydown', function(event) {
// 只拦截我们关心的按键，且不在输入框中
if (keysToCatch.includes(event.key) &&
event.target.tagName !== 'INPUT' &&
event.target.tagName !== 'TEXTAREA') {
// 标记这个事件已被我们的脚本处理
event._handledBySpeedController = true;
}
}, true);
// 如果网站使用特定库，修改它们的行为而不是完全禁用
// 处理keyboardJS库
if (window.keyboardJS && typeof window.keyboardJS.bind === 'function') {
const originalBind = window.keyboardJS.bind;
window.keyboardJS.bind = function(key, pressHandler, releaseHandler) {
// 如果绑定的是我们使用的键，则包装其处理程序
if (keysToCatch.includes(key)) {
const wrappedPressHandler = function(e) {
if (e._handledBySpeedController) return;
if (pressHandler) pressHandler(e);
};
const wrappedReleaseHandler = function(e) {
if (e._handledBySpeedController) return;
if (releaseHandler) releaseHandler(e);
};
return originalBind.call(this, key, wrappedPressHandler, wrappedReleaseHandler);
}
// 其他键正常绑定
return originalBind.apply(this, arguments);
};
console.log('已修改keyboardJS.bind以处理冲突键');
}
// 处理Mousetrap库
if (window.Mousetrap && typeof window.Mousetrap.bind === 'function') {
const originalBind = window.Mousetrap.prototype.bind;
window.Mousetrap.prototype.bind = function(keys, callback, action) {
// 检查单个键或键数组
const keysArray = Array.isArray(keys) ? keys : [keys];
const hasConflict = keysArray.some(k => keysToCatch.includes(k));
if (hasConflict) {
// 包装回调函数
const wrappedCallback = function(e, combo) {
if (e._handledBySpeedController) return;
if (callback) return callback(e, combo);
};
return originalBind.call(this, keys, wrappedCallback, action);
}
// 其他键正常绑定
return originalBind.apply(this, arguments);
};
console.log('已修改Mousetrap.bind以处理冲突键');
}
console.log('成功设置冲突按键处理');
} catch(e) {
console.error('设置按键冲突处理失败:', e);
}
})();
`;
document.body.appendChild(script);
document.body.removeChild(script);
log('已设置按键冲突处理');
}
// 键盘事件处理，使用捕获阶段以确保我们的处理器先运行
function handleKeyPress(event) {
// 忽略在输入框中的按键事件
if (event.target.tagName === 'INPUT' || event.target.tagName === 'TEXTAREA') {
return;
}
const key = event.key;
// 检查是否匹配我们的快捷键
let handled = false;
switch (key) {
case config.hotkeys.increaseSpeed:
changeSpeed(config.speedStep);
handled = true;
break;
case config.hotkeys.decreaseSpeed:
changeSpeed(-config.speedStep);
handled = true;
break;
case config.hotkeys.resetSpeed:
resetSpeed();
handled = true;
break;
case config.hotkeys.doubleSpeed:
doubleSpeed();
handled = true;
break;
}
if (handled) {
// 如果处理了快捷键，阻止事件冒泡和默认行为
event.stopPropagation();
event.preventDefault();
}
}
// 处理URL变化的函数 - 增强检测
function handleUrlChange() {
const newUrl = location.href;
if (newUrl !== currentVideoUrl) {
log(`检测到URL变化，从 ${currentVideoUrl} 到 ${newUrl}`);
currentVideoUrl = newUrl;
// URL变化时重置视频元素和状态
videoElement = null;
speedApplied = false;
// 重置视频记录时间
videoFoundTime = null;
// 重新查找视频元素，使用渐进式延迟
const delays = [500, 1000, 2000, 3000, 5000, 8000, 13000];
delays.forEach((delay, index) => {
setTimeout(() => {
if (!videoElement) {
log(`URL变更后第${index + 1}次查找视频 (延迟${delay}ms)`);
videoElement = findVideoElement();
if (videoElement) {
log('URL变化后找到视频元素');
applyInitialSpeed();
}
}
}, delay);
});
}
}
// 设置MutationObserver监视DOM变化
function setupVideoObserver() {
if (videoObserver) {
videoObserver.disconnect();
}
videoObserver = new MutationObserver((mutations) => {
// 如果还没找到视频元素，继续尝试
if (!videoElement) {
videoElement = findVideoElement();
if (videoElement) {
log('MutationObserver找到视频元素');
speedApplied = false;
applyInitialSpeed();
}
}
// 检查是否有新的视频加载（例如切换到新一集）
for (const mutation of mutations) {
if (mutation.type === 'childList') {
for (const node of mutation.addedNodes) {
if (node.nodeName === 'VIDEO' ||
(node.nodeType === Node.ELEMENT_NODE && node.querySelector('video'))) {
const newVideo = node.nodeName === 'VIDEO' ? node : node.querySelector('video');
if (newVideo && newVideo !== videoElement && isVideoPlayable(newVideo)) {
log('检测到新的视频元素');
videoElement = newVideo;
speedApplied = false;
applyInitialSpeed();
}
}
}
}
}
// 检查视频src变化，可能是同一个视频元素载入新内容
if (videoElement && !speedApplied) {
applyInitialSpeed();
}
});
videoObserver.observe(document.body, {
childList: true,
subtree: true,
attributes: true,
attributeFilter: ['src']
});
log('已设置视频元素观察器');
}
// 改进版应用初始播放速度 - 减少自动干预但改进对慢加载视频的处理
function applyInitialSpeed() {
// 如果已经应用过速度，不重复应用
if (speedApplied) {
return;
}
if (videoElement) {
// 记录找到视频的时间
if (!videoFoundTime) {
videoFoundTime = Date.now();
}
const speed = getLastSpeed();
log(`准备应用上次使用的速度: ${speed}x`);
// 首次应用速度，增加延迟等待视频完全加载
setTimeout(() => {
try {
// 检查视频readyState是否足够应用速度
if (videoElement.readyState >= 2) {
videoElement.playbackRate = speed;
log(`成功应用播放速度: ${speed}x (readyState=${videoElement.readyState})`);
showNotification(`应用播放速度: ${speed}x`);
speedApplied = true;
// 添加事件监听，但只在播放开始时检查一次，不持续监听
videoElement.addEventListener('play', function() {
// 只在播放开始时检查一次
if (videoElement.playbackRate !== speed) {
log(`检测到播放开始时速度不正确，重新应用: ${speed}x`);
videoElement.playbackRate = speed;
}
}, { once: true });
// 监听loadeddata事件确保在数据加载后应用速度
videoElement.addEventListener('loadeddata', function() {
if (videoElement.playbackRate !== speed) {
log(`检测到视频数据加载后速度不正确，重新应用: ${speed}x`);
videoElement.playbackRate = speed;
}
}, { once: true });
} else {
// 视频尚未准备好，设置重试
log(`视频元素readyState不足 (${videoElement.readyState})，设置重试`);
// 使用条件触发的事件监听器
const eventTypes = ['loadedmetadata', 'loadeddata', 'canplay', 'canplaythrough'];
// 为每个事件类型添加一次性监听器
eventTypes.forEach(eventType => {
videoElement.addEventListener(eventType, function() {
if (!speedApplied && videoElement.readyState >= 2) {
log(`在 ${eventType} 事件后应用速度 ${speed}x`);
try {
videoElement.playbackRate = speed;
showNotification(`应用播放速度: ${speed}x`);
speedApplied = true;
} catch (e) {
log(`在 ${eventType} 事件后设置速度失败: ${e.message}`);
}
}
}, { once: true });
});
// 添加备用延迟尝试，以防事件未触发
setTimeout(() => {
if (!speedApplied) {
log('使用备用延迟尝试应用速度');
try {
videoElement.playbackRate = speed;
log(`延迟备用设置成功 (readyState=${videoElement.readyState})`);
showNotification(`应用播放速度: ${speed}x`);
speedApplied = true;
} catch (e) {
log(`延迟备用设置失败: ${e.message}`);
}
}
}, 4000);
}
} catch (e) {
log(`应用播放速度失败: ${e.message}`);
// 设置递增延迟的备用尝试
const retryDelays = [2000, 4000, 8000];
retryDelays.forEach((delay, index) => {
setTimeout(() => {
if (!speedApplied) {
try {
log(`第${index + 1}次重试应用速度 ${speed}x`);
videoElement.playbackRate = speed;
log(`重试成功`);
showNotification(`应用播放速度: ${speed}x`);
speedApplied = true;
} catch (err) {
log(`第${index + 1}次重试失败: ${err.message}`);
}
}
}, delay);
});
}
}, 1000); // 给视频更多时间加载
} else if (waitingForVideo) {
// 如果在等待视频但没有找到，不执行额外操作
log('等待视频元素出现...');
} else {
// 启动长期监控以处理非常慢的视频加载
startLongTermMonitoring();
}
}
// 启动长期监控以处理特别慢的视频加载
function startLongTermMonitoring() {
if (longTermMonitoringTimer) {
clearInterval(longTermMonitoringTimer);
}
log('启动长期监控以等待视频加载');
let monitoringStartTime = Date.now();
longTermMonitoringTimer = setInterval(() => {
const elapsedTime = Date.now() - monitoringStartTime;
// 如果监控时间过长，停止监控
if (elapsedTime > config.longTermMonitoring) {
log('长期监控超时，停止监控');
clearInterval(longTermMonitoringTimer);
return;
}
// 如果已经找到视频并应用了速度，停止监控
if (videoElement && speedApplied) {
log('视频已找到并应用了速度，停止长期监控');
clearInterval(longTermMonitoringTimer);
return;
}
// 如果找到了视频但还没应用速度
if (videoElement && !speedApplied) {
log('发现视频尚未应用速度，尝试应用');
applyInitialSpeed();
return;
}
// 尝试再次查找视频
log(`长期监控：第${Math.floor(elapsedTime / config.longTermCheckInterval)}次尝试查找视频`);
videoElement = findVideoElement();
if (videoElement) {
log('长期监控找到视频元素');
applyInitialSpeed();
}
}, config.longTermCheckInterval);
}
// 主初始化函数
function initialize() {
log('初始化中...');
// 加载保存的速度
lastStoredSpeed = getLastSpeed();
log(`初始化时加载速度: ${lastStoredSpeed}x`);
// 添加样式
addStyles();
// 创建通知元素
createNotification();
// 处理冲突按键而不是禁用所有键盘事件
handleConflictingKeyBindings();
// 监听键盘事件 - 使用捕获阶段以确保我们的处理器先运行
document.addEventListener('keydown', handleKeyPress, true);
// 监听URL变化
if (window.history && window.history.pushState) {
// 监听popstate事件
window.addEventListener('popstate', handleUrlChange);
// 重写history方法以捕获SPA页面变化
const originalPushState = window.history.pushState;
window.history.pushState = function() {
originalPushState.apply(this, arguments);
handleUrlChange();
};
const originalReplaceState = window.history.replaceState;
window.history.replaceState = function() {
originalReplaceState.apply(this, arguments);
handleUrlChange();
};
}
// 定期检查URL变化（用于不触发history事件的变化）
setInterval(handleUrlChange, 4000);
// 设置视频观察器
setupVideoObserver();
// 延迟查找视频以处理慢加载
log(`等待${config.initialWaitTime / 1000}秒后开始查找视频...`);
setTimeout(() => {
// 立即尝试查找视频
videoElement = findVideoElement();
if (videoElement) {
log('初始化时找到视频元素');
applyInitialSpeed();
return;
}
// 如果没有立即找到，定期尝试
log('未立即找到视频，启动定期查找');
let findVideoInterval = setInterval(() => {
retryCount++;
videoElement = findVideoElement();
if (videoElement) {
log(`在第${retryCount}次尝试时找到视频元素`);
clearInterval(findVideoInterval);
applyInitialSpeed();
return;
}
if (retryCount >= config.maxRetries) {
log('达到最大尝试次数，仍未找到视频元素');
clearInterval(findVideoInterval);
// 最后尝试一次并启动长期监控
setTimeout(() => {
videoElement = findVideoElement();
if (videoElement) {
log('最后一次常规尝试找到视频元素');
applyInitialSpeed();
} else {
log('常规查找未找到视频，切换到长期监控');
startLongTermMonitoring();
}
}, 10000);
}
}, config.retryInterval);
}, config.initialWaitTime);
// 显示通知脚本已加载
showNotification('视频倍速控制已加载 [慢视频优化版]');
}
// 等待页面加载完成并初始化
if (document.readyState === 'loading') {
document.addEventListener('DOMContentLoaded', () => setTimeout(initialize, 1000));
} else {
setTimeout(initialize, 1000); // 给页面更多时间加载JS
}
})();