flux-dl 1.1.3 → 1.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flux-dl",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Leistungsstarke Video-Downloader Library für YouTube, Vimeo und Dailymotion - komplett in JavaScript, keine externen Binaries",
   "main": "src/index.js",
   "scripts": {

package/src/VideoDownloader.js

@@ -5,6 +5,7 @@ const platforms = require('./platforms');
 const VideoEncryption = require('./utils/encryption');
 const RequestSpoofing = require('./utils/requestSpoofing');
 const BrowserEmulation = require('./utils/browserEmulation');
+const QualityManager = require('./utils/qualityManager');
 
 class VideoDownloader {
   constructor(options = {}) {
@@ -13,17 +14,24 @@ class VideoDownloader {
       timeout: 30000,
       encryptionKey: options.encryptionKey || 'default-key',
       cookiesFile: options.cookiesFile,
+      quality: options.quality || 192, // Standard: Medium (192 kbps)
       ...options
     };
     
     this.encryption = new VideoEncryption(this.options.encryptionKey);
     this.spoofing = new RequestSpoofing();
     this.browser = new BrowserEmulation();
+    this.qualityManager = new QualityManager();
     
     // Load cookies if provided
     if (this.options.cookiesFile) {
       this.browser.cookieManager.loadFromFile(this.options.cookiesFile);
     }
+
+    // Set default quality if provided
+    if (options.quality) {
+      this.qualityManager.setDefaultQuality(options.quality);
+    }
   }
 
   async getVideoInfo(url) {
@@ -347,6 +355,169 @@ class VideoDownloader {
   signUrl(url, expiresIn = 3600) {
     return this.encryption.signUrl(url, expiresIn);
   }
+
+  // ========== QUALITY MANAGEMENT API ==========
+
+  /**
+   * Setzt die Qualität für einen bestimmten User
+   * @param {string} userId - User ID
+   * @param {number} quality - Bitrate (120-360 kbps)
+   * @returns {number} Gesetzte Qualität
+   */
+  setUserQuality(userId, quality) {
+    return this.qualityManager.setUserQuality(userId, quality);
+  }
+
+  /**
+   * Gibt die erlaubte Qualität für einen User zurück
+   * @param {string} userId - User ID
+   * @param {boolean} isPremium - Ist Premium User?
+   * @returns {number} Erlaubte Bitrate
+   */
+  getUserQuality(userId, isPremium = false) {
+    return this.qualityManager.getUserQuality(userId, isPremium);
+  }
+
+  /**
+   * Setzt globale Standard-Qualität
+   * @param {number} quality - Bitrate (120-360 kbps)
+   */
+  setDefaultQuality(quality) {
+    this.qualityManager.setDefaultQuality(quality);
+    this.options.quality = quality;
+  }
+
+  /**
+   * Setzt maximale Qualität für Free Users
+   * @param {number} quality - Bitrate (120-360 kbps)
+   */
+  setMaxQualityForFreeUsers(quality) {
+    this.qualityManager.setMaxQualityForFreeUsers(quality);
+  }
+
+  /**
+   * Setzt maximale Qualität für Premium Users
+   * @param {number} quality - Bitrate (120-360 kbps)
+   */
+  setMaxQualityForPremiumUsers(quality) {
+    this.qualityManager.setMaxQualityForPremiumUsers(quality);
+  }
+
+  /**
+   * Gibt verfügbare Qualitätsstufen für User zurück
+   * @param {string} userId - User ID
+   * @param {boolean} isPremium - Ist Premium User?
+   * @returns {Array} Verfügbare Stufen
+   */
+  getAvailableQualities(userId, isPremium = false) {
+    return this.qualityManager.getAvailableQualities(userId, isPremium);
+  }
+
+  /**
+   * Prüft ob User bestimmte Qualität nutzen darf
+   * @param {string} userId - User ID
+   * @param {number} requestedQuality - Gewünschte Qualität
+   * @param {boolean} isPremium - Ist Premium User?
+   * @returns {boolean} Erlaubt?
+   */
+  canUserUseQuality(userId, requestedQuality, isPremium = false) {
+    return this.qualityManager.canUserUseQuality(userId, requestedQuality, isPremium);
+  }
+
+  /**
+   * Download mit User-spezifischer Qualität
+   * @param {string} url - Video URL
+   * @param {string} outputPath - Output Pfad
+   * @param {string} userId - User ID
+   * @param {boolean} isPremium - Ist Premium User?
+   * @param {function} onProgress - Progress Callback
+   * @returns {Promise<Object>} Download Result
+   */
+  async downloadAudioWithQuality(url, outputPath, userId, isPremium = false, onProgress = null) {
+    const userQuality = this.getUserQuality(userId, isPremium);
+    
+    console.log(`🎵 Downloading for user ${userId}`);
+    console.log(`📊 Quality: ${this.qualityManager.getQualityLabel(userQuality)}`);
+    
+    // Temporär Qualität setzen
+    const originalQuality = this.options.quality;
+    this.options.quality = userQuality;
+    
+    try {
+      const result = await this.downloadAudio(url, outputPath, onProgress);
+      return {
+        ...result,
+        quality: userQuality,
+        qualityLabel: this.qualityManager.getQualityLabel(userQuality)
+      };
+    } finally {
+      // Qualität zurücksetzen
+      this.options.quality = originalQuality;
+    }
+  }
+
+  /**
+   * Stream mit User-spezifischer Qualität
+   * @param {string} url - Video URL
+   * @param {string} userId - User ID
+   * @param {boolean} isPremium - Ist Premium User?
+   * @param {function} onProgress - Progress Callback
+   * @returns {Promise<Object>} Stream Result
+   */
+  async getAudioStreamWithQuality(url, userId, isPremium = false, onProgress = null) {
+    const userQuality = this.getUserQuality(userId, isPremium);
+    
+    console.log(`🎵 Streaming for user ${userId}`);
+    console.log(`📊 Quality: ${this.qualityManager.getQualityLabel(userQuality)}`);
+    
+    // Temporär Qualität setzen
+    const originalQuality = this.options.quality;
+    this.options.quality = userQuality;
+    
+    try {
+      const result = await this.getAudioStream(url, onProgress);
+      return {
+        ...result,
+        quality: userQuality,
+        qualityLabel: this.qualityManager.getQualityLabel(userQuality)
+      };
+    } finally {
+      // Qualität zurücksetzen
+      this.options.quality = originalQuality;
+    }
+  }
+
+  /**
+   * Entfernt User-Permission
+   * @param {string} userId - User ID
+   */
+  removeUserQuality(userId) {
+    this.qualityManager.removeUserQuality(userId);
+  }
+
+  /**
+   * Gibt alle User-Permissions zurück
+   * @returns {Object} User-Permissions
+   */
+  getAllUserPermissions() {
+    return this.qualityManager.getAllUserPermissions();
+  }
+
+  /**
+   * Exportiert Quality-Konfiguration
+   * @returns {Object} Konfiguration
+   */
+  exportQualityConfig() {
+    return this.qualityManager.exportConfig();
+  }
+
+  /**
+   * Importiert Quality-Konfiguration
+   * @param {Object} config - Konfiguration
+   */
+  importQualityConfig(config) {
+    this.qualityManager.importConfig(config);
+  }
 }
 
 module.exports = VideoDownloader;

package/src/index.js

@@ -1,11 +1,13 @@
 const VideoDownloader = require('./VideoDownloader');
 const VideoEncryption = require('./utils/encryption');
 const YouTubeSearch = require('./utils/youtubeSearch');
+const QualityManager = require('./utils/qualityManager');
 const { supportedPlatforms } = require('./platforms');
 
 module.exports = {
   VideoDownloader,
   VideoEncryption,
   YouTubeSearch,
+  QualityManager,
   supportedPlatforms
 };

package/src/utils/qualityManager.js

@@ -0,0 +1,270 @@
+/**
+ * QUALITY MANAGER - Audio Bitrate Control System
+ * Verwaltet Audio-Qualität mit User-Permissions (120-360 kbps)
+ */
+
+class QualityManager {
+  constructor() {
+    // Qualitätsstufen (in kbps für Audio)
+    this.QUALITY_LEVELS = {
+      MINIMUM: 120,    // Niedrigste Qualität
+      LOW: 128,        // Niedrig
+      MEDIUM: 192,     // Mittel (Standard)
+      HIGH: 256,       // Hoch
+      MAXIMUM: 360     // Höchste Qualität
+    };
+
+    // User-Permissions (wer darf welche Qualität nutzen)
+    this.userPermissions = new Map();
+    
+    // Globale Einstellungen
+    this.defaultQuality = this.QUALITY_LEVELS.MEDIUM;
+    this.maxQualityForFreeUsers = this.QUALITY_LEVELS.MEDIUM;
+    this.maxQualityForPremiumUsers = this.QUALITY_LEVELS.MAXIMUM;
+  }
+
+  /**
+   * Setzt die erlaubte Qualität für einen User
+   * @param {string} userId - User ID
+   * @param {number} maxQuality - Maximale Bitrate (120-360)
+   */
+  setUserQuality(userId, maxQuality) {
+    const quality = this.validateQuality(maxQuality);
+    this.userPermissions.set(userId, quality);
+    return quality;
+  }
+
+  /**
+   * Gibt die erlaubte Qualität für einen User zurück
+   * @param {string} userId - User ID
+   * @param {boolean} isPremium - Ist der User Premium?
+   * @returns {number} Erlaubte Bitrate
+   */
+  getUserQuality(userId, isPremium = false) {
+    // Wenn User spezifische Permission hat
+    if (this.userPermissions.has(userId)) {
+      return this.userPermissions.get(userId);
+    }
+
+    // Sonst nach Premium-Status
+    return isPremium ? this.maxQualityForPremiumUsers : this.maxQualityForFreeUsers;
+  }
+
+  /**
+   * Validiert und begrenzt Qualitätswert
+   * @param {number} quality - Gewünschte Bitrate
+   * @returns {number} Validierte Bitrate (120-360)
+   */
+  validateQuality(quality) {
+    const q = parseInt(quality);
+    
+    if (isNaN(q)) {
+      return this.defaultQuality;
+    }
+
+    // Begrenze auf Min/Max
+    if (q < this.QUALITY_LEVELS.MINIMUM) {
+      return this.QUALITY_LEVELS.MINIMUM;
+    }
+    
+    if (q > this.QUALITY_LEVELS.MAXIMUM) {
+      return this.QUALITY_LEVELS.MAXIMUM;
+    }
+
+    return q;
+  }
+
+  /**
+   * Wählt das beste Audio-Format basierend auf Qualitätseinstellung
+   * @param {Array} formats - Verfügbare Formate
+   * @param {number} targetQuality - Ziel-Bitrate
+   * @returns {Object} Bestes Format
+   */
+  selectBestAudioFormat(formats, targetQuality) {
+    // Nur Audio-Formate
+    const audioFormats = formats.filter(f => 
+      f.mimeType && f.mimeType.includes('audio') && f.url
+    );
+
+    if (audioFormats.length === 0) return null;
+
+    // Sortiere nach Bitrate
+    audioFormats.sort((a, b) => {
+      const bitrateA = this.getBitrate(a);
+      const bitrateB = this.getBitrate(b);
+      return Math.abs(bitrateA - targetQuality) - Math.abs(bitrateB - targetQuality);
+    });
+
+    // Finde Format das am nächsten zur Ziel-Qualität ist
+    let bestFormat = audioFormats[0];
+    
+    for (const format of audioFormats) {
+      const bitrate = this.getBitrate(format);
+      
+      // Wenn Format unter Ziel-Qualität liegt, nehme es
+      if (bitrate <= targetQuality && bitrate > this.getBitrate(bestFormat)) {
+        bestFormat = format;
+      }
+    }
+
+    return bestFormat;
+  }
+
+  /**
+   * Extrahiert Bitrate aus Format
+   * @param {Object} format - Format-Objekt
+   * @returns {number} Bitrate in kbps
+   */
+  getBitrate(format) {
+    if (format.bitrate) {
+      return Math.round(format.bitrate / 1000); // Bits zu kbps
+    }
+    
+    if (format.audioBitrate) {
+      return format.audioBitrate;
+    }
+
+    // Fallback: Schätze aus Quality-Label
+    if (format.qualityLabel) {
+      const match = format.qualityLabel.match(/(\d+)kbps/i);
+      if (match) {
+        return parseInt(match[1]);
+      }
+    }
+
+    // Default: Mittel
+    return this.QUALITY_LEVELS.MEDIUM;
+  }
+
+  /**
+   * Gibt Qualitäts-Label zurück
+   * @param {number} bitrate - Bitrate in kbps
+   * @returns {string} Label
+   */
+  getQualityLabel(bitrate) {
+    if (bitrate >= this.QUALITY_LEVELS.MAXIMUM) return '🔥 Maximum (360 kbps)';
+    if (bitrate >= this.QUALITY_LEVELS.HIGH) return '⭐ High (256 kbps)';
+    if (bitrate >= this.QUALITY_LEVELS.MEDIUM) return '✅ Medium (192 kbps)';
+    if (bitrate >= this.QUALITY_LEVELS.LOW) return '📊 Low (128 kbps)';
+    return '💾 Minimum (120 kbps)';
+  }
+
+  /**
+   * Setzt globale Standard-Qualität
+   * @param {number} quality - Bitrate (120-360)
+   */
+  setDefaultQuality(quality) {
+    this.defaultQuality = this.validateQuality(quality);
+  }
+
+  /**
+   * Setzt maximale Qualität für Free Users
+   * @param {number} quality - Bitrate (120-360)
+   */
+  setMaxQualityForFreeUsers(quality) {
+    this.maxQualityForFreeUsers = this.validateQuality(quality);
+  }
+
+  /**
+   * Setzt maximale Qualität für Premium Users
+   * @param {number} quality - Bitrate (120-360)
+   */
+  setMaxQualityForPremiumUsers(quality) {
+    this.maxQualityForPremiumUsers = this.validateQuality(quality);
+  }
+
+  /**
+   * Entfernt User-Permission
+   * @param {string} userId - User ID
+   */
+  removeUserQuality(userId) {
+    this.userPermissions.delete(userId);
+  }
+
+  /**
+   * Gibt alle User-Permissions zurück
+   * @returns {Object} User-Permissions
+   */
+  getAllUserPermissions() {
+    const permissions = {};
+    for (const [userId, quality] of this.userPermissions.entries()) {
+      permissions[userId] = {
+        quality,
+        label: this.getQualityLabel(quality)
+      };
+    }
+    return permissions;
+  }
+
+  /**
+   * Prüft ob User bestimmte Qualität nutzen darf
+   * @param {string} userId - User ID
+   * @param {number} requestedQuality - Gewünschte Qualität
+   * @param {boolean} isPremium - Ist Premium User?
+   * @returns {boolean} Erlaubt?
+   */
+  canUserUseQuality(userId, requestedQuality, isPremium = false) {
+    const maxAllowed = this.getUserQuality(userId, isPremium);
+    return requestedQuality <= maxAllowed;
+  }
+
+  /**
+   * Gibt verfügbare Qualitätsstufen für User zurück
+   * @param {string} userId - User ID
+   * @param {boolean} isPremium - Ist Premium User?
+   * @returns {Array} Verfügbare Stufen
+   */
+  getAvailableQualities(userId, isPremium = false) {
+    const maxQuality = this.getUserQuality(userId, isPremium);
+    const available = [];
+
+    for (const [name, value] of Object.entries(this.QUALITY_LEVELS)) {
+      if (value <= maxQuality) {
+        available.push({
+          name,
+          value,
+          label: this.getQualityLabel(value)
+        });
+      }
+    }
+
+    return available;
+  }
+
+  /**
+   * Exportiert Konfiguration
+   * @returns {Object} Konfiguration
+   */
+  exportConfig() {
+    return {
+      defaultQuality: this.defaultQuality,
+      maxQualityForFreeUsers: this.maxQualityForFreeUsers,
+      maxQualityForPremiumUsers: this.maxQualityForPremiumUsers,
+      userPermissions: Object.fromEntries(this.userPermissions)
+    };
+  }
+
+  /**
+   * Importiert Konfiguration
+   * @param {Object} config - Konfiguration
+   */
+  importConfig(config) {
+    if (config.defaultQuality) {
+      this.defaultQuality = this.validateQuality(config.defaultQuality);
+    }
+    
+    if (config.maxQualityForFreeUsers) {
+      this.maxQualityForFreeUsers = this.validateQuality(config.maxQualityForFreeUsers);
+    }
+    
+    if (config.maxQualityForPremiumUsers) {
+      this.maxQualityForPremiumUsers = this.validateQuality(config.maxQualityForPremiumUsers);
+    }
+    
+    if (config.userPermissions) {
+      this.userPermissions = new Map(Object.entries(config.userPermissions));
+    }
+  }
+}
+
+module.exports = QualityManager;