☰

YouTube CPU Tamer by AnimationFrame

Reduce Browser's Energy Impact for playing YouTube Video

当前为 2022-07-24 提交的版本，查看 最新版本。

  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     2022.07.24
  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. // @match     https://www.youtube.com/*
  17. // @match     https://www.youtube.com/embed/*
  18. // @match     https://www.youtube-nocookie.com/embed/*
  19. // @match     https://www.youtube.com/live_chat*
  20. // @match     https://www.youtube.com/live_chat_replay*
  21. // @match     https://music.youtube.com/*
  22. // @icon         https://www.google.com/s2/favicons?domain=youtube.com
  23. // @run-at      document-start
  24. // @grant       none
  25. // ==/UserScript==
  26. (function $$() {
  27.     'use strict';
  28.     
  29.     const [window, document] = new Function('return [window, document];')(); // real window & document object
  30.     
  31.     const hkey_script = 'nzsxclvflluv';
  32.     if (window[hkey_script]) return; // avoid duplicated scripting
  33.     window[hkey_script] = true;
  34.     
  35.     //if (!document.documentElement) return window.requestAnimationFrame($$); // not required to check documentElement ready or not
  36.     
  37.     // copies of native functions
  38.     const $$requestAnimationFrame = window.requestAnimationFrame.bind(window); // core looping
  39.     const $$setTimeout = window.setTimeout.bind(window); // for race
  40.     const $$setInterval = window.setInterval.bind(window); // for background execution
  41.     const $$clearTimeout = window.clearTimeout.bind(window); // for native clearTimeout
  42.     const $$clearInterval = window.clearInterval.bind(window); // for native clearInterval
  43.     
  44.     const $busy = Symbol('$busy');
  45.     
  46.     // Number.MAX_SAFE_INTEGER = 9007199254740991
  47.     
  48.     const INT_INITIAL_VALUE = 8192; // 1 ~ {INT_INITIAL_VALUE} are reserved for native setTimeout/setInterval
  49.     const SAFE_INT_LIMIT = 2251799813685248; // in case cid would be used for multiplying
  50.     const SAFE_INT_REDUCED = 67108864; // avoid persistent interval handlers with cids between {INT_INITIAL_VALUE + 1} and {SAFE_INT_REDUCED - 1}
  51.     
  52.     let mi = INT_INITIAL_VALUE; // skip first {INT_INITIAL_VALUE} cids to avoid browser not yet initialized
  53.     const sb = {};
  54.     const sFunc = (prop) => {
  55.         return (func, ms, ...args) => {
  56.             mi++; // start at {INT_INITIAL_VALUE + 1}
  57.             if (mi > SAFE_INT_LIMIT) mi = SAFE_INT_REDUCED; // just in case
  58.             let handler = args.length > 0 ? func.bind(null, ...args) : func; // original func if no extra argument
  59.             handler[$busy] || (handler[$busy] = 0);
  60.             sb[mi] = {
  61.                 handler
  62.                 , [prop]: ms, // timeout / interval; value can be undefined
  63.                 nextAt: Date.now() + (ms > 0 ? ms : 0) // overload for setTimeout(func);
  64.             };
  65.             return mi;
  66.         };
  67.     };
  68.     const rm = function (jd) {
  69.         if (!jd) return; // native setInterval & setTimeout start from 1
  70.         let o = sb[jd];
  71.         if (typeof o != 'object') { // to clear the same cid is unlikely to happen || requiring nativeFn is unlikely to happen
  72.             if (jd <= INT_INITIAL_VALUE) this.nativeFn(jd); // only for clearTimeout & clearInterval
  73.             return;
  74.         }
  75.         for (let k in o) o[k] = null;
  76.         o = null;
  77.         sb[jd] = null;
  78.         delete sb[jd];
  79.     };
  80.     window.setTimeout = sFunc('timeout');
  81.     window.setInterval = sFunc('interval');
  82.     window.clearTimeout = rm.bind({
  83.         nativeFn: $$clearTimeout
  84.     });
  85.     window.clearInterval = rm.bind({
  86.         nativeFn: $$clearInterval
  87.     });
  88.     // window.clearInterval = window.clearTimeout = rm;
  89.     
  90.     const delay16ms = (resolve => $$setTimeout(resolve, 16));
  91.     
  92.     const pf = (
  93.         handler => new Promise(resolve => {
  94.             // try catch is not required - no further execution on the handler
  95.             // 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)
  96.             // For function handler with low energy impact, discard or not discard depends on system performance
  97.             if (handler[$busy] == 1) handler();
  98.             handler[$busy]--;
  99.             handler = null; // remove the reference of `handler`
  100.             resolve();
  101.             resolve = null; // remove the reference of `resolve`
  102.         })
  103.     );
  104.     
  105.     let toResetFuncHandlers = false;
  106.     let bgExecutionAt = 0; // set at 0 to trigger tf in background startup when requestAnimationFrame is not responsive
  107.     
  108.     let dexActivePage = true; // true for default; false when checking triggered by setInterval 
  109.     let interupter = null;
  110.     const raf = $$requestAnimationFrame.bind(window);
  111.     const infiniteLooper = (resolve) => {
  112.         interupter = resolve;
  113.         if (dexActivePage) raf(resolve); // if dexActivePage = false, the checking will be triggered by setInterval
  114.     }
  115.     
  116.     const mbx1 = async () => {
  117.         // microTask #1
  118.         let now = Date.now();
  119.         //bgExecutionAt = now + 160; // if requestAnimationFrame is not responsive (e.g. background running)
  120.         let promisesF = [];
  121.         for (let jb in sb) {
  122.             const o = sb[jb];
  123.             let {
  124.                 handler,
  125.                 // timeout,
  126.                 interval
  127.                 , nextAt
  128.             } = o;
  129.             if (now < nextAt) continue;
  130.             handler[$busy]++;
  131.             promisesF.push(handler);
  132.             if (interval > 0) { // prevent undefined, zero, negative values
  133.                 const _interval = +interval; // convertion from string to number if necessary; decimal is acceptable
  134.                 if (o.nextAt + _interval > now) o.nextAt += _interval;
  135.                 else if (o.nextAt + 2 * _interval > now) o.nextAt += 2 * _interval;
  136.                 else if (o.nextAt + 3 * _interval > now) o.nextAt += 3 * _interval;
  137.                 else if (o.nextAt + 4 * _interval > now) o.nextAt += 4 * _interval;
  138.                 else if (o.nextAt + 5 * _interval > now) o.nextAt += 5 * _interval;
  139.                 else o.nextAt = now + _interval;
  140.             } else {
  141.                 // jb in sb must > INT_INITIAL_VALUE
  142.                 rm(jb); // remove timeout
  143.             }
  144.         }
  145.         return promisesF;
  146.     };
  147.     
  148.     let mbx2 = async (promisesF) => {
  149.         // microTask #2
  150.         //bgExecutionAt = Date.now() + 160; // if requestAnimationFrame is not responsive (e.g. background running)
  151.         if (promisesF.length == 0) { // no handler functions
  152.             // requestAnimationFrame when the page is active
  153.             // execution interval is no less than AnimationFrame
  154.         } else if (dexActivePage) {
  155.             let ret2 = new Promise(delay16ms);
  156.             let ret3 = new Promise(resolveK => {
  157.                 // error would not affect calling the next tick
  158.                 Promise.all(promisesF.map(pf)).then(resolveK); //microTasks
  159.                 promisesF.length = 0;
  160.             })
  161.             let race = Promise.race([ret2, ret3]);
  162.             // ensure checking function must be called after 16ms to maintain visual changes in high fps.
  163.             // >16ms examples: repaint/reflow, change of style/content
  164.             await race;
  165.         } else {
  166.             new Promise(resolveK => {
  167.                 // error would not affect calling the next tick
  168.                 promisesF.forEach(pf); //microTasks
  169.                 promisesF.length = 0;
  170.             })
  171.         }
  172.     };
  173.     
  174.     (async () => {
  175.         while (true) {
  176.             bgExecutionAt = Date.now() + 160;
  177.             let interupterRes = await new Promise(infiniteLooper);
  178.             interupter = null;
  179.             if (dexActivePage === false && interupterRes !== true) toResetFuncHandlers = true;
  180.             dexActivePage = (interupterRes !== true);
  181.             if (toResetFuncHandlers) {
  182.                 toResetFuncHandlers = false;
  183.                 for (let jb in sb) sb[jb].handler[$busy] = 0; // including the functions with error
  184.             }
  185.             let promisesF = await mbx1();
  186.             await mbx2(promisesF);
  187.         }
  188.     })();
  189.     
  190.     $$setInterval(() => {
  191.         // no response of requestAnimationFrame; e.g. running in background
  192.         if (interupter && Date.now() > bgExecutionAt) {
  193.             interupter(document.hidden ? true : false); // if interupter is not called, wait for the next tick
  194.         }
  195.     }, 250);
  196.     // i.e. 4 times per second for background execution - to keep YouTube application functional
  197.     // if there is Timer Throttling for background running, the execution become the same as native setTimeout & setInterval.
  198.         
  199.     window.addEventListener("yt-navigate-finish", () => {
  200.         toResetFuncHandlers = true; // ensure all function handlers can be executed after YouTube navigation.
  201.     }, true); // capturing event - to let it runs before all everything else.
  202.         
  203.     // Your code here...
  204. })();