add: implement SabrStream for adaptive bitrate streaming

Author: 1Lucas1apk

src/playback/player.js

@@ -421,6 +421,11 @@ export class Player {
     if (startTime)
       urlData.additionalData = { startTime, ...urlData.additionalData }
 
+    urlData.additionalData = {
+      ...urlData.additionalData,
+      positionCallback: () => this._realPosition()
+    }
+
     const track = urlData?.newTrack ? urlData?.newTrack?.info : info
     const fetched = await this.nodelink.sources.getTrackStream(
       track,

src/sources/youtube/YouTube.js

@@ -10,6 +10,7 @@ import TVEmbedded from './clients/TVEmbedded.js'
 import Web from './clients/Web.js'
 import { checkURLType, YOUTUBE_CONSTANTS } from './common.js'
 import OAuth from './OAuth.js'
+import { SabrStream } from './sabr.js'
 
 const CHUNK_SIZE = 64 * 1024
 const MAX_RETRIES = 3
@@ -1010,6 +1011,10 @@ export default class YouTubeSource {
           continue
         }
 
+        if (urlData.protocol === 'sabr') {
+          return urlData
+        }
+
         if (urlData.url) {
           const check = await http1makeRequest(urlData.url, {
             method: 'GET',
@@ -1155,6 +1160,38 @@ export default class YouTubeSource {
     this.activeStreams.set(streamKey, cancelSignal)
 
     try {
+      if (protocol === 'sabr') {
+        const sabr = new SabrStream({
+          videoId: decodedTrack.identifier,
+          accessToken: additionalData.accessToken,
+          visitorData: additionalData.visitorData,
+          serverAbrStreamingUrl: additionalData.serverAbrStreamingUrl,
+          videoPlaybackUstreamerConfig: additionalData.videoPlaybackUstreamerConfig,
+          poToken: additionalData.poToken,
+          clientInfo: additionalData.clientInfo,
+          formats: additionalData.formats,
+          startTime: additionalData.startTime || 0,
+          positionCallback: additionalData.positionCallback
+        })
+
+        const stream = new PassThrough()
+
+        sabr.on('data', (chunk) => stream.write(chunk))
+        sabr.on('end', () => stream.end())
+        sabr.on('error', (err) => {
+          logger('error', 'YouTube', `SABR stream error: ${err.message}`)
+          stream.destroy(err)
+        })
+
+        const bestAudio = additionalData.formats.filter(f => f.mimeType?.includes('audio')).sort((a, b) => (b.bitrate || 0) - (a.bitrate || 0))[0]
+        
+        sabr.start(bestAudio.itag)
+
+        const type = bestAudio.mimeType?.includes('webm') ? 'webm/opus' : 'm4a'
+
+        return { stream, type }
+      }
+
       if (protocol === 'hls') {
         const stream = new PassThrough()
         _manageYoutubeHlsStream(url, stream, cancelSignal, streamKey, this)

src/sources/youtube/clients/Web.js

@@ -5,20 +5,22 @@ import {
   buildTrack,
   checkURLType
 } from '../common.js'
+import { PoTokenManager } from '../potoke.js'
 
 export default class Web extends BaseClient {
   constructor(nodelink, oauth) {
     super(nodelink, 'WEB', oauth)
+    this.poTokenManager = new PoTokenManager()
   }
 
   getClient(context) {
     return {
       client: {
         clientName: 'WEB',
-        clientVersion: '2.20260101.00.00',
+        clientVersion: '2.20260107.01.00',
         platform: 'DESKTOP',
         userAgent:
-          'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36,gzip(gfe)',
+          'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36',
         hl: context.client.hl,
         gl: context.client.gl
       },
@@ -248,33 +250,120 @@ export default class Web extends BaseClient {
   }
 
   async getTrackUrl(decodedTrack, context, cipherManager, itag) {
-    const sourceName = decodedTrack.sourceName || 'youtube'
-    logger(
-      'debug',
-      'youtube-web',
-      `Getting stream URL for: ${decodedTrack.title} (ID: ${decodedTrack.identifier}) on ${sourceName}`
-    )
+    if (this.oauth && this.oauth.accessToken) {
+      await this.oauth.getAccessToken()
+    }
 
-    const { body: playerResponse, statusCode } = await this._makePlayerRequest(
-      decodedTrack.identifier,
-      context,
-      {},
-      cipherManager
-    )
+    const { poToken, visitorData } = await this.poTokenManager.generate(decodedTrack.identifier)
+    
+    if (poToken) {
+      const client = this.getClient(context)
+      client.client.visitorData = visitorData
+
+      let signatureTimestamp = null
+      try {
+        const playerScript = await cipherManager.getCachedPlayerScript()
+        if (playerScript) {
+          signatureTimestamp = await cipherManager.getTimestamp(playerScript.url)
+        }
+      } catch (e) {
+        logger('warn', 'YouTube-Web', `Failed to get STS: ${e.message}`)
+      }
+
+      const requestBody = {
+        context: client,
+        videoId: decodedTrack.identifier,
+        contentCheckOk: true,
+        racyCheckOk: true,
+        serviceIntegrityDimensions: { poToken }
+      }
 
-    if (statusCode !== 200) {
-      const message = `Failed to get player data for stream. Status: ${statusCode}`
-      logger('error', 'youtube-web', message)
-      return { exception: { message, severity: 'common', cause: 'Upstream' } }
+      if (signatureTimestamp) {
+        requestBody.playbackContext = {
+          contentPlaybackContext: {
+            signatureTimestamp
+          }
+        }
+      }
+
+      try {
+        const { body: playerResponse } = await makeRequest(
+          'https://youtubei.googleapis.com/youtubei/v1/player?prettyPrint=false', 
+          {
+            method: 'POST',
+            headers: {
+              'User-Agent': client.client.userAgent,
+              'X-Goog-Visitor-Id': visitorData,
+              'X-Youtube-Client-Name': '1',
+              'X-Youtube-Client-Version': client.client.clientVersion,
+              'Origin': 'https://www.youtube.com',
+              'Referer': `https://www.youtube.com/watch?v=${decodedTrack.identifier}`
+            },
+            body: requestBody,
+            disableBodyCompression: true
+          }
+        )
+
+        const streamingData = playerResponse.streamingData || playerResponse.streaming_data
+        const serverAbrUrl = streamingData?.serverAbrStreamingUrl || streamingData?.server_abr_streaming_url
+        const ustreamerConfig = playerResponse.playerConfig?.mediaCommonConfig?.mediaUstreamerRequestConfig?.videoPlaybackUstreamerConfig
+
+        if (serverAbrUrl) {
+          const playerScript = await cipherManager.getCachedPlayerScript()
+          
+          let resolvedUrl = serverAbrUrl
+          if (playerScript) {
+            try {
+              resolvedUrl = await cipherManager.resolveUrl(
+                serverAbrUrl,
+                null,
+                null,
+                null,
+                playerScript,
+                context
+              )
+            } catch (e) {
+              logger('warn', 'YouTube-Web', `Failed to resolve SABR URL via cipher server: ${e.message}`)
+            }
+          }
+
+          const formats = [...(streamingData.formats || []), ...(streamingData.adaptiveFormats || streamingData.adaptive_formats || [])].map(f => ({
+            itag: f.itag,
+            lastModified: f.lastModified || f.last_modified_ms,
+            xtags: f.xtags,
+            width: f.width,
+            height: f.height,
+            mimeType: f.mimeType || f.mime_type,
+            audioQuality: f.audioQuality || f.audio_quality,
+            bitrate: f.bitrate,
+            averageBitrate: f.averageBitrate || f.average_bitrate,
+            quality: f.quality,
+            qualityLabel: f.qualityLabel || f.quality_label,
+            audioTrackId: f.audioTrack?.id,
+            approxDurationMs: f.approxDurationMs || f.approx_duration_ms,
+            contentLength: f.contentLength || f.content_length,
+            isDrc: !!f.isDrc
+          }))
+
+          return {
+            protocol: 'sabr',
+            url: resolvedUrl,
+            additionalData: {
+              serverAbrStreamingUrl: resolvedUrl,
+              videoPlaybackUstreamerConfig: ustreamerConfig,
+              poToken,
+              visitorData,
+              clientInfo: { clientName: 1, clientVersion: client.client.clientVersion },
+              formats,
+              accessToken: null,
+              userAgent: client.client.userAgent
+            }
+          }
+        }
+      } catch (e) {}
     }
 
-    return await this._extractStreamData(
-      playerResponse,
-      decodedTrack,
-      context,
-      cipherManager,
-      itag
-    )
+    return super.getTrackUrl(decodedTrack, context, cipherManager, itag)
   }
 
   async getChapters(trackInfo, context) {

src/sources/youtube/potoke.js

@@ -0,0 +1,85 @@
+import { Buffer } from 'node:buffer'
+import { base64ToU8 } from './protor.js'
+
+const PO_CONFIG = {
+  apiKey: 'AIzaSyDyT5W0Jh49F30Pqqtyfdf7pDLFKLJoAnw',
+  userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36',
+  clientVersion: '2.20260107.01.00',
+  integrityUrl: 'https://www.youtube.com/api/jnn/v1/GenerateIT'
+};
+
+export class PoTokenManager {
+  async generate(videoId) {
+    try {
+      const { visitorData, botguardData } = await this.getPageContext(videoId);
+      const { snapshot } = await this.createSnapshot();
+      const integrityToken = await this.requestIntegrityToken(snapshot, botguardData.requestKey);
+      const poToken = await this.bindToken(integrityToken, visitorData);
+      return { poToken, visitorData };
+    } catch (error) {
+      return { poToken: null, visitorData: null };
+    }
+  }
+
+  async getPageContext(videoId) {
+    const res = await fetch(`https://www.youtube.com/watch?v=${videoId}`, {
+      headers: { 'User-Agent': PO_CONFIG.userAgent }
+    });
+    const html = await res.text();
+    const visitorDataMatch = html.match(/"visitorData":"([^"]+)"/);
+    if (!visitorDataMatch) throw new Error('Could not find visitorData');
+    const visitorData = visitorDataMatch[1];
+    const stsMatch = html.match(/"signatureTimestamp":(\d+)/);
+    const signatureTimestamp = stsMatch ? parseInt(stsMatch[1]) : 20455;
+
+    const playerRes = await fetch('https://youtubei.googleapis.com/youtubei/v1/player', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'User-Agent': PO_CONFIG.userAgent,
+        'X-Goog-Visitor-Id': visitorData
+      },
+      body: JSON.stringify({
+        videoId,
+        playbackContext: { contentPlaybackContext: { signatureTimestamp } },
+        context: { client: { clientName: 'WEB', clientVersion: PO_CONFIG.clientVersion, visitorData, userAgent: PO_CONFIG.userAgent } }
+      })
+    });
+
+    const body = await playerRes.json();
+    const botguardData = body.botguardData || { requestKey: 'fixed_key' };
+    return { visitorData, botguardData };
+  }
+
+  async createSnapshot() {
+    const signals = new Uint8Array([0x12, 0x1a, 0x0a, 0x08, 0x01, 0x12, 0x04, 0x08, 0x01, 0x10, 0x01]);
+    return { snapshot: Buffer.from(signals).toString('base64'), signals };
+  }
+
+  async requestIntegrityToken(snapshot, requestKey) {
+    const res = await fetch(PO_CONFIG.integrityUrl, {
+      method: 'POST',
+      headers: { 
+        'Content-Type': 'application/json+protobuf', 
+        'X-Goog-Api-Key': PO_CONFIG.apiKey,
+        'X-User-Agent': 'grpc-web-javascript/0.1'
+      },
+      body: JSON.stringify([requestKey, snapshot])
+    });
+    const body = await res.json();
+    return body[0];
+  }
+
+  async bindToken(integrityToken, visitorData) {
+    const itBytes = base64ToU8(integrityToken);
+    const vdBytes = Buffer.from(visitorData, 'utf8');
+    const buffer = new Uint8Array(10 + itBytes.length + vdBytes.length);
+    buffer[0] = 0x22; buffer[1] = buffer.length - 2;
+    buffer.set([0x5a, 0xb3, 0x00, 0x01], 2);
+    new DataView(buffer.buffer, 6, 4).setUint32(0, Math.floor(Date.now() / 1000), false);
+    buffer.set(itBytes, 10); buffer.set(vdBytes, 10 + itBytes.length);
+    const payload = buffer.subarray(2);
+    for (let i = 2; i < payload.length; i++) payload[i] ^= i % 2 === 0 ? 0x5a : 0xb3;
+    return Buffer.from(buffer).toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+  }
+}