☰

YouTube CPU Tamer by AnimationFrame

Reduce Browser's Energy Impact for playing YouTube Video

当前为 2021-09-02 提交的版本，查看 最新版本。

  1. // ==UserScript==
  2. // @name         YouTube CPU Tamer by AnimationFrame
  3. // @name:en      YouTube CPU Tamer by AnimationFrame
  4. // @name:jp      YouTube CPU Tamer by AnimationFrame
  5. // @name:zh-tw   YouTube CPU Tamer by AnimationFrame
  6. // @name:zh-cn   YouTube CPU Tamer by AnimationFrame
  7. // @namespace    http://tampermonkey.net/
  8. // @version     2021.09.02.1
  9. // @license     MIT License
  10. // @description     Reduce Browser's Energy Impact for playing YouTube Video
  11. // @description:en  Reduce Browser's Energy Impact for playing YouTube Video
  12. // @description:jp  YouTubeビデオのエネルギーインパクトを減らす
  13. // @description:zh-tw  減少YouTube影片所致的能源消耗
  14. // @description:zh-cn  减少YouTube影片所致的能源消耗
  15. // @author       CY Fung
  16. // @include     https://www.youtube.com/*
  17. // @include     https://www.youtube.com/embed/*
  18. // @include     https://www.youtube-nocookie.com/embed/*
  19. // @include     https://www.youtube.com/live_chat*
  20. // @include     https://www.youtube.com/live_chat_replay*
  21. // @icon         https://www.google.com/s2/favicons?domain=youtube.com
  22. // @run-at      document-start
  23. // @grant       none
  24. // ==/UserScript==
  25. (function $$() {
  26.     'use strict';
  27.  
  28.     const window = new Function('return window;')(); // real window object
  29.  
  30.     const hkey_script = 'nzsxclvflluv';
  31.     if (window[hkey_script]) return; // avoid duplicated scripting
  32.     window[hkey_script] = true;
  33.  
  34.     //if (!document.documentElement) return window.requestAnimationFrame($$); // no document access
  35.  
  36.     // copies of native functions
  37.     const $$requestAnimationFrame = window.requestAnimationFrame.bind(window); // core looping
  38.     const $$setTimeout = window.setTimeout.bind(window); // for race
  39.     const $$setInterval = window.setInterval.bind(window); // for background execution
  40.  
  41.     const $busy = Symbol('$busy');
  42.  
  43.     let mi = 0;
  44.     const sb = {};
  45.     const sFunc = (prop) => {
  46.         return (func, ms, ...args) => {
  47.             mi++; // start at 1
  48.             let handler = args.length > 0 ? func.bind(null, ...args) : func; // original func if no extra argument
  49.             handler[$busy] = handler[$busy] || 0;
  50.             sb[mi] = {
  51.                 handler,
  52.                 [prop]: ms, // timeout / interval; value can be undefined
  53.                 nextAt: Date.now() + (ms > 0 ? ms : 0) // overload for setTimeout(func);
  54.             };
  55.             return mi;
  56.         };
  57.     };
  58.     const rm = (jd) => {
  59.         let o = sb[jd];
  60.         if (typeof o != 'object') return;
  61.         for (let k in o) o[k] = null;
  62.         o = null;
  63.         sb[jd] = null;
  64.         delete sb[jd];
  65.     };
  66.     window.setTimeout = sFunc('timeout');
  67.     window.setInterval = sFunc('interval');
  68.     window.clearInterval = window.clearTimeout = rm;
  69.  
  70.  
  71.     const pf = (
  72.         handler => new Promise(resolve => {
  73.             // try catch is not required - no further execution on the handler
  74.             // For function handler with high energy impact, discard 1st, 2nd, ... (n-1)th calling:  (a,b,c,a,b,d,e,f) => (c,a,b,d,e,f)
  75.             // For function handler with low energy impact, discard or not discard depends on system performance
  76.             if (handler[$busy] == 1) handler();
  77.             handler[$busy]--;
  78.             resolve();
  79.         })
  80.     );
  81.  
  82.     let jf, tf, toResetFuncHandlers = false;
  83.     let bgExecutionAt = 0; // set at 0 to trigger tf in background startup when requestAnimationFrame is not responsive
  84.     tf = () => {
  85.         if (toResetFuncHandlers) {
  86.             toResetFuncHandlers = false;
  87.             for (let jb in sb) sb[jb].handler[$busy] = 0;
  88.         }
  89.         new Promise(resolveApp1 => {
  90.             // microTask #1
  91.             let now = Date.now();
  92.             bgExecutionAt = now + 160; // if requestAnimationFrame is not responsive (e.g. background running)
  93.             let promisesF = [];
  94.             for (let jb in sb) {
  95.                 const o = sb[jb];
  96.                 let {
  97.                     handler,
  98.                     // timeout,
  99.                     interval,
  100.                     nextAt
  101.                 } = o;
  102.                 if (now < nextAt) continue;
  103.                 handler[$busy]++;
  104.                 promisesF.push(handler);
  105.                 if (interval > 0) { // prevent undefined, zero, negative values
  106.                     o.nextAt += +interval; // convertion from string to number if necessary; decimal is acceptable
  107.                 } else {
  108.                     rm(jb); // remove timeout
  109.                 }
  110.             }
  111.             resolveApp1(promisesF);
  112.         }).then(promisesF => {
  113.             // microTask #2
  114.             bgExecutionAt = Date.now() + 160; // if requestAnimationFrame is not responsive (e.g. background running)
  115.             let hidden = document.hidden; // background running would not call requestAnimationFrame
  116.             if (promisesF.length == 0) { // no handler functions
  117.                 // requestAnimationFrame when the page is active
  118.                 // execution interval is no less than AnimationFrame
  119.                 return hidden || jf();
  120.             }
  121.             if (!hidden) {
  122.                 let ret2 = new Promise(resolve => $$setTimeout(resolve, 16));
  123.                 let promises = promisesF.map(pf); //microTasks
  124.                 let ret1 = Promise.all(promises);
  125.                 let race = Promise.race([ret1, ret2]);
  126.                 // ensure jf must be called after 16ms to maintain visual changes in high fps.
  127.                 // >16ms examples: repaint/reflow, change of style/content
  128.                 race.then(jf);
  129.                 promises.length = 0;
  130.             } else {
  131.                 promisesF.forEach(pf);
  132.             }
  133.             promisesF.length = 0;
  134.         })
  135.     };
  136.     (jf = $$requestAnimationFrame.bind(window, tf))();
  137.  
  138.     $$setInterval(() => {
  139.         // no response of requestAnimationFrame; e.g. running in background
  140.         // toResetFuncHandlers = true;
  141.         if (Date.now() > bgExecutionAt) {
  142.             toResetFuncHandlers = true;
  143.             tf();
  144.         }
  145.     }, 250);
  146.     // i.e. 4 times per second for background execution - to keep YouTube application functional
  147.  
  148.     window.addEventListener("yt-navigate-finish", () => {
  149.         toResetFuncHandlers = true; // ensure all function handlers can be executed after YouTube navigation.
  150.     }, true); // capturing event - to let it runs before all everything else.
  151.  
  152.     // Your code here...
  153. })();