@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/media/video/processor/streaming.d.ts

@@ -0,0 +1,26 @@
+/**
+ * STX Media - Video Streaming Manifest Generation
+ *
+ * Generate HLS and DASH manifests for adaptive streaming.
+ *
+ * @module media/video/processor/streaming
+ */
+import type { HLSResult, DASHResult, StreamingQualityLevel } from '../../types';
+/**
+ * Default streaming quality levels
+ */
+export declare const DEFAULT_STREAMING_QUALITIES: StreamingQualityLevel[];
+/**
+ * Generate HLS (HTTP Live Streaming) manifest and segments
+ */
+export declare function generateHLSManifest(src: string, qualities: StreamingQualityLevel[], outputDir: string, baseUrl: string, options?: {
+    segmentDuration?: number;
+    playlistType?: 'vod' | 'event';
+}): Promise<HLSResult | null>;
+/**
+ * Generate DASH (Dynamic Adaptive Streaming over HTTP) manifest
+ */
+export declare function generateDASHManifest(src: string, qualities: StreamingQualityLevel[], outputDir: string, baseUrl: string, options?: {
+    segmentDuration?: number;
+    minBufferTime?: number;
+}): Promise<DASHResult | null>;

package/dist/media/video/processor/streaming.js

@@ -0,0 +1,197 @@
+import { resolve, basename, extname, join } from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+import { hashFile, fileExists } from "../../shared/hash.js";
+async function getTsVideos() {
+  try {
+    return await import("ts-videos");
+  } catch {
+    return null;
+  }
+}
+export const DEFAULT_STREAMING_QUALITIES = [
+  { label: "1080p", width: 1920, height: 1080, bitrate: 5000000, audioBitrate: 192000 },
+  { label: "720p", width: 1280, height: 720, bitrate: 2500000, audioBitrate: 128000 },
+  { label: "480p", width: 854, height: 480, bitrate: 1e6, audioBitrate: 96000 },
+  { label: "360p", width: 640, height: 360, bitrate: 600000, audioBitrate: 64000 }
+];
+export async function generateHLSManifest(src, qualities, outputDir, baseUrl, options) {
+  const tsVideos = await getTsVideos();
+  if (!tsVideos) {
+    console.warn("[stx-media] ts-videos not installed, cannot generate HLS manifest");
+    return null;
+  }
+  try {
+    const srcPath = resolve(src);
+    if (!await fileExists(srcPath))
+      return null;
+    const srcHash = await hashFile(srcPath), srcBasename = basename(src, extname(src)), hlsDir = join(outputDir, `${srcBasename}-${srcHash}-hls`);
+    await mkdir(hlsDir, { recursive: !0 });
+    const effectiveQualities = qualities.length > 0 ? qualities : DEFAULT_STREAMING_QUALITIES, segmentDuration = options?.segmentDuration || 6, duration = (await new tsVideos.Input(srcPath).getInfo()).duration || 0, playlists = [];
+    let totalSegments = 0;
+    for (const quality of effectiveQualities) {
+      const qualityDir = join(hlsDir, quality.label);
+      await mkdir(qualityDir, { recursive: !0 });
+      const playlistFilename = `${quality.label}.m3u8`, playlistPath = join(qualityDir, playlistFilename);
+      try {
+        const result = await tsVideos.generateHLS(srcPath, {
+          outputDir: qualityDir,
+          segmentDuration,
+          width: quality.width,
+          height: quality.height,
+          videoBitrate: quality.bitrate,
+          audioBitrate: quality.audioBitrate,
+          playlistName: quality.label
+        });
+        if (result) {
+          playlists.push({
+            quality,
+            url: `${baseUrl}/${srcBasename}-${srcHash}-hls/${quality.label}/${playlistFilename}`,
+            path: playlistPath
+          });
+          totalSegments += result.segmentCount || Math.ceil(duration / segmentDuration);
+        }
+      } catch (error) {
+        console.warn(`[stx-media] Failed to generate HLS for ${quality.label}: ${error}`);
+      }
+    }
+    if (playlists.length === 0)
+      return null;
+    const masterPlaylistPath = join(hlsDir, "master.m3u8"), masterPlaylist = generateMasterPlaylist(playlists, baseUrl, srcBasename, srcHash);
+    await writeFile(masterPlaylistPath, masterPlaylist);
+    return {
+      manifestUrl: `${baseUrl}/${srcBasename}-${srcHash}-hls/master.m3u8`,
+      manifestPath: masterPlaylistPath,
+      playlists,
+      segmentCount: totalSegments,
+      duration
+    };
+  } catch (error) {
+    console.warn(`[stx-media] Failed to generate HLS manifest: ${error}`);
+    return null;
+  }
+}
+function generateMasterPlaylist(playlists, baseUrl, srcBasename, srcHash) {
+  const lines = ["#EXTM3U", "#EXT-X-VERSION:3"];
+  for (const playlist of playlists) {
+    const { quality } = playlist, bandwidth = quality.bitrate + (quality.audioBitrate || 128000), resolution = `${quality.width}x${quality.height || Math.round(quality.width * 9 / 16)}`;
+    lines.push(`#EXT-X-STREAM-INF:BANDWIDTH=${bandwidth},RESOLUTION=${resolution},NAME="${quality.label}"`, `${quality.label}/${quality.label}.m3u8`);
+  }
+  return lines.join(`
+`);
+}
+export async function generateDASHManifest(src, qualities, outputDir, baseUrl, options) {
+  const tsVideos = await getTsVideos();
+  if (!tsVideos) {
+    console.warn("[stx-media] ts-videos not installed, cannot generate DASH manifest");
+    return null;
+  }
+  try {
+    const srcPath = resolve(src);
+    if (!await fileExists(srcPath))
+      return null;
+    const srcHash = await hashFile(srcPath), srcBasename = basename(src, extname(src)), dashDir = join(outputDir, `${srcBasename}-${srcHash}-dash`);
+    await mkdir(dashDir, { recursive: !0 });
+    const effectiveQualities = qualities.length > 0 ? qualities : DEFAULT_STREAMING_QUALITIES, segmentDuration = options?.segmentDuration || 4, minBufferTime = options?.minBufferTime || 2, duration = (await new tsVideos.Input(srcPath).getInfo()).duration || 0, videoRepresentations = [], audioRepresentations = [];
+    for (const quality of effectiveQualities) {
+      const qualityDir = join(dashDir, quality.label);
+      await mkdir(qualityDir, { recursive: !0 });
+      try {
+        if (await tsVideos.generateDASH(srcPath, {
+          outputDir: qualityDir,
+          segmentDuration,
+          width: quality.width,
+          height: quality.height,
+          videoBitrate: quality.bitrate,
+          audioBitrate: quality.audioBitrate
+        })) {
+          videoRepresentations.push({
+            bandwidth: quality.bitrate,
+            width: quality.width,
+            height: quality.height || Math.round(quality.width * 9 / 16),
+            url: `${baseUrl}/${srcBasename}-${srcHash}-dash/${quality.label}/video`
+          });
+          if (quality.audioBitrate)
+            audioRepresentations.push({
+              bandwidth: quality.audioBitrate,
+              url: `${baseUrl}/${srcBasename}-${srcHash}-dash/${quality.label}/audio`
+            });
+        }
+      } catch (error) {
+        console.warn(`[stx-media] Failed to generate DASH for ${quality.label}: ${error}`);
+      }
+    }
+    if (videoRepresentations.length === 0)
+      return null;
+    const mpdPath = join(dashDir, "manifest.mpd"), mpd = generateMPD(videoRepresentations, audioRepresentations, duration, segmentDuration, minBufferTime);
+    await writeFile(mpdPath, mpd);
+    const adaptationSets = [
+      { type: "video", representations: videoRepresentations }
+    ];
+    if (audioRepresentations.length > 0)
+      adaptationSets.push({ type: "audio", representations: audioRepresentations });
+    return {
+      manifestUrl: `${baseUrl}/${srcBasename}-${srcHash}-dash/manifest.mpd`,
+      manifestPath: mpdPath,
+      adaptationSets,
+      duration
+    };
+  } catch (error) {
+    console.warn(`[stx-media] Failed to generate DASH manifest: ${error}`);
+    return null;
+  }
+}
+function generateMPD(videoReps, audioReps, duration, segmentDuration, minBufferTime) {
+  const durationISO = formatISODuration(duration), minBufferISO = formatISODuration(minBufferTime);
+  let mpd = `<?xml version="1.0" encoding="UTF-8"?>
+<MPD xmlns="urn:mpeg:dash:schema:mpd:2011"
+     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+     xsi:schemaLocation="urn:mpeg:dash:schema:mpd:2011 DASH-MPD.xsd"
+     type="static"
+     mediaPresentationDuration="${durationISO}"
+     minBufferTime="${minBufferISO}"
+     profiles="urn:mpeg:dash:profile:isoff-on-demand:2011">
+  <Period>
+    <AdaptationSet mimeType="video/mp4" codecs="avc1.64001f" segmentAlignment="true" startWithSAP="1">
+`;
+  for (let i = 0;i < videoReps.length; i++) {
+    const rep = videoReps[i];
+    mpd += `      <Representation id="video${i}" bandwidth="${rep.bandwidth}" width="${rep.width}" height="${rep.height}">
+        <BaseURL>${rep.url}/</BaseURL>
+        <SegmentBase indexRange="0-999">
+          <Initialization range="0-999"/>
+        </SegmentBase>
+      </Representation>
+`;
+  }
+  mpd += `    </AdaptationSet>
+`;
+  if (audioReps.length > 0) {
+    mpd += `    <AdaptationSet mimeType="audio/mp4" codecs="mp4a.40.2" segmentAlignment="true" startWithSAP="1">
+`;
+    for (let i = 0;i < audioReps.length; i++) {
+      const rep = audioReps[i];
+      mpd += `      <Representation id="audio${i}" bandwidth="${rep.bandwidth}">
+        <BaseURL>${rep.url}/</BaseURL>
+        <SegmentBase indexRange="0-999">
+          <Initialization range="0-999"/>
+        </SegmentBase>
+      </Representation>
+`;
+    }
+    mpd += `    </AdaptationSet>
+`;
+  }
+  mpd += `  </Period>
+</MPD>`;
+  return mpd;
+}
+function formatISODuration(seconds) {
+  const hours = Math.floor(seconds / 3600), minutes = Math.floor(seconds % 3600 / 60), secs = Math.floor(seconds % 60);
+  let duration = "PT";
+  if (hours > 0)
+    duration += `${hours}H`;
+  if (minutes > 0)
+    duration += `${minutes}M`;
+  duration += `${secs}S`;
+  return duration;
+}

package/dist/media/video/processor/thumbnail.d.ts

@@ -0,0 +1,35 @@
+/**
+ * STX Media - Video Thumbnail Generation
+ *
+ * Generate poster images, thumbnails, and sprite sheets from video.
+ *
+ * @module media/video/processor/thumbnail
+ */
+import type { ThumbnailResult, PosterGenerationConfig, SpriteSheetConfig } from '../../types';
+/**
+ * Generate poster/thumbnail from video at specific timestamp
+ */
+export declare function generatePoster(src: string, options: PosterGenerationConfig, outputDir: string, baseUrl: string): Promise<ThumbnailResult | null>;
+/**
+ * Generate multiple thumbnails at intervals
+ */
+export declare function generateThumbnails(src: string, options: {
+    count?: number;
+    interval?: number;
+    format?: 'jpeg' | 'png' | 'webp';
+    width?: number;
+    quality?: number;
+}, outputDir: string, baseUrl: string): Promise<ThumbnailResult[]>;
+/**
+ * Generate sprite sheet for video scrubbing preview
+ */
+export declare function generateSpriteSheet(src: string, options: SpriteSheetConfig, outputDir: string, baseUrl: string): Promise<{
+    url: string;
+    path: string;
+    columns: number;
+    rows: number;
+    thumbnailWidth: number;
+    thumbnailHeight: number;
+    interval: number;
+    totalFrames: number;
+} | null>;

package/dist/media/video/processor/thumbnail.js

@@ -0,0 +1,134 @@
+import { resolve, basename, extname, join } from "node:path";
+import { mkdir } from "node:fs/promises";
+import { hashFile, fileExists } from "../../shared/hash.js";
+async function getTsVideos() {
+  try {
+    return await import("ts-videos");
+  } catch {
+    return null;
+  }
+}
+export async function generatePoster(src, options, outputDir, baseUrl) {
+  const tsVideos = await getTsVideos();
+  if (!tsVideos) {
+    console.warn("[stx-media] ts-videos not installed, cannot generate poster");
+    return null;
+  }
+  try {
+    const srcPath = resolve(src);
+    if (!await fileExists(srcPath))
+      return null;
+    await mkdir(outputDir, { recursive: !0 });
+    const srcHash = await hashFile(srcPath), srcBasename = basename(src, extname(src)), format = options.format || "webp", timestamp = options.timestamp || 0, outputFilename = `${srcBasename}-poster-${srcHash}.${format}`, outputPath = join(outputDir, outputFilename), result = await tsVideos.extractThumbnails(srcPath, {
+      timestamps: [timestamp],
+      width: options.width || 1280,
+      height: options.height,
+      format,
+      quality: options.quality || 85,
+      outputDir,
+      outputPattern: outputFilename.replace(`.${format}`, "")
+    });
+    if (result && result.length > 0) {
+      const thumb = result[0];
+      return {
+        path: outputPath,
+        url: `${baseUrl}/${outputFilename}`,
+        width: thumb.width || options.width || 1280,
+        height: thumb.height || 720,
+        timestamp,
+        size: thumb.size || 0
+      };
+    }
+    return null;
+  } catch (error) {
+    console.warn(`[stx-media] Failed to generate poster: ${error}`);
+    return null;
+  }
+}
+export async function generateThumbnails(src, options, outputDir, baseUrl) {
+  const tsVideos = await getTsVideos();
+  if (!tsVideos)
+    return [];
+  try {
+    const srcPath = resolve(src);
+    if (!await fileExists(srcPath))
+      return [];
+    await mkdir(outputDir, { recursive: !0 });
+    const srcHash = await hashFile(srcPath), srcBasename = basename(src, extname(src)), format = options.format || "webp", duration = (await new tsVideos.Input(srcPath).getInfo()).duration || 60, count = options.count || 10, interval = options.interval || duration / count, timestamps = [];
+    for (let i = 0;i < count && i * interval < duration; i++)
+      timestamps.push(i * interval);
+    const result = await tsVideos.extractThumbnails(srcPath, {
+      timestamps,
+      width: options.width || 320,
+      format,
+      quality: options.quality || 80,
+      outputDir,
+      outputPattern: `${srcBasename}-thumb-${srcHash}`
+    });
+    if (result && result.length > 0)
+      return result.map((thumb, index) => ({
+        path: thumb.path || join(outputDir, `${srcBasename}-thumb-${srcHash}-${index}.${format}`),
+        url: `${baseUrl}/${srcBasename}-thumb-${srcHash}-${index}.${format}`,
+        width: thumb.width || options.width || 320,
+        height: thumb.height || 180,
+        timestamp: timestamps[index],
+        size: thumb.size || 0
+      }));
+    return [];
+  } catch (error) {
+    console.warn(`[stx-media] Failed to generate thumbnails: ${error}`);
+    return [];
+  }
+}
+export async function generateSpriteSheet(src, options, outputDir, baseUrl) {
+  const tsVideos = await getTsVideos();
+  if (!tsVideos) {
+    console.warn("[stx-media] ts-videos not installed, cannot generate sprite sheet");
+    return null;
+  }
+  try {
+    const srcPath = resolve(src);
+    if (!await fileExists(srcPath))
+      return null;
+    await mkdir(outputDir, { recursive: !0 });
+    const srcHash = await hashFile(srcPath), srcBasename = basename(src, extname(src)), duration = (await new tsVideos.Input(srcPath).getInfo()).duration || 60, columns = options.columns || 10, interval = options.interval || 5, thumbnailWidth = options.thumbnailWidth || 160, thumbnailHeight = options.thumbnailHeight || 90, format = options.format || "jpeg", totalFrames = Math.ceil(duration / interval), rows = Math.ceil(totalFrames / columns), outputFilename = `${srcBasename}-sprite-${srcHash}.${format}`, outputPath = join(outputDir, outputFilename), timestamps = [];
+    for (let i = 0;i < totalFrames; i++)
+      timestamps.push(i * interval);
+    const thumbnails = await tsVideos.extractThumbnails(srcPath, {
+      timestamps,
+      width: thumbnailWidth,
+      height: thumbnailHeight,
+      format,
+      quality: options.quality || 70,
+      outputDir: join(outputDir, ".temp")
+    });
+    if (!thumbnails || thumbnails.length === 0)
+      return null;
+    try {
+      const tsImages = await import("ts-images"), spriteWidth = columns * thumbnailWidth, spriteHeight = rows * thumbnailHeight, sprite = await tsImages.createSprite({
+        images: thumbnails.map((t) => t.path),
+        columns,
+        padding: 0,
+        outputPath,
+        format,
+        quality: options.quality || 70
+      });
+      return {
+        url: `${baseUrl}/${outputFilename}`,
+        path: outputPath,
+        columns,
+        rows,
+        thumbnailWidth,
+        thumbnailHeight,
+        interval,
+        totalFrames
+      };
+    } catch {
+      console.warn("[stx-media] ts-images not installed, sprite sheet generation skipped");
+      return null;
+    }
+  } catch (error) {
+    console.warn(`[stx-media] Failed to generate sprite sheet: ${error}`);
+    return null;
+  }
+}

package/dist/media/video/processor/transcoder.d.ts

@@ -0,0 +1,19 @@
+/**
+ * STX Media - Video Transcoder
+ *
+ * Wraps ts-videos for video transcoding and analysis.
+ *
+ * @module media/video/processor/transcoder
+ */
+import type { EnhancedVideoProps, ProcessedVideoResult, TsVideosConfig } from '../../types';
+/**
+ * Analyze video to get metadata
+ */
+export declare function analyzeVideo(src: string): Promise<ProcessedVideoResult['metadata'] | null>;
+/**
+ * Process a video with ts-videos
+ */
+export declare function processVideo(src: string, options: Partial<EnhancedVideoProps>, config: TsVideosConfig, onProgress?: (progress: {
+    percentage: number;
+    stage: string;
+}) => void): Promise<ProcessedVideoResult>;

package/dist/media/video/processor/transcoder.js

@@ -0,0 +1,283 @@
+import { resolve, basename, extname, join } from "node:path";
+import { mkdir } from "node:fs/promises";
+import { hashFile, fileExists } from "../../shared/hash.js";
+import { getCachedVideoResult, setCachedVideoResult } from "./cache.js";
+import { generatePoster, generateThumbnails } from "./thumbnail.js";
+import { generateHLSManifest, generateDASHManifest } from "./streaming.js";
+async function getTsVideos() {
+  try {
+    return await import("ts-videos");
+  } catch {
+    return null;
+  }
+}
+function getQualityBitrate(preset) {
+  switch (preset) {
+    case "very-low":
+      return 500000;
+    case "low":
+      return 1e6;
+    case "medium":
+      return 2500000;
+    case "high":
+      return 5000000;
+    case "very-high":
+      return 1e7;
+    case "lossless":
+      return 0;
+    default:
+      return 2500000;
+  }
+}
+function getPlatformSettings(platform) {
+  switch (platform) {
+    case "youtube":
+      return {
+        codec: "h264",
+        maxWidth: 1920,
+        maxHeight: 1080,
+        frameRate: 30,
+        audioCodec: "aac",
+        audioBitrate: 128000
+      };
+    case "twitter":
+      return {
+        codec: "h264",
+        maxWidth: 1280,
+        maxHeight: 720,
+        frameRate: 30,
+        bitrate: 5000000,
+        audioCodec: "aac",
+        audioBitrate: 128000
+      };
+    case "instagram-feed":
+      return {
+        codec: "h264",
+        maxWidth: 1080,
+        maxHeight: 1080,
+        frameRate: 30,
+        bitrate: 3500000,
+        audioCodec: "aac",
+        audioBitrate: 128000
+      };
+    case "instagram-story":
+    case "instagram-reels":
+      return {
+        codec: "h264",
+        maxWidth: 1080,
+        maxHeight: 1920,
+        frameRate: 30,
+        bitrate: 3500000,
+        audioCodec: "aac",
+        audioBitrate: 128000
+      };
+    case "tiktok":
+      return {
+        codec: "h264",
+        maxWidth: 1080,
+        maxHeight: 1920,
+        frameRate: 30,
+        bitrate: 4000000,
+        audioCodec: "aac",
+        audioBitrate: 128000
+      };
+    case "discord":
+      return {
+        codec: "h264",
+        maxWidth: 1920,
+        maxHeight: 1080,
+        frameRate: 60,
+        bitrate: 8000000,
+        audioCodec: "aac",
+        audioBitrate: 192000
+      };
+    case "linkedin":
+      return {
+        codec: "h264",
+        maxWidth: 1920,
+        maxHeight: 1080,
+        frameRate: 30,
+        bitrate: 5000000,
+        audioCodec: "aac",
+        audioBitrate: 128000
+      };
+    case "facebook":
+      return {
+        codec: "h264",
+        maxWidth: 1280,
+        maxHeight: 720,
+        frameRate: 30,
+        bitrate: 4000000,
+        audioCodec: "aac",
+        audioBitrate: 128000
+      };
+    case "web-progressive":
+      return {
+        codec: "h264",
+        maxWidth: 1920,
+        maxHeight: 1080,
+        frameRate: 30,
+        audioCodec: "aac",
+        audioBitrate: 128000,
+        twoPass: !0
+      };
+    case "web-streaming":
+      return {
+        codec: "h264",
+        maxWidth: 1920,
+        maxHeight: 1080,
+        frameRate: 30,
+        audioCodec: "aac",
+        audioBitrate: 128000
+      };
+    default:
+      return {};
+  }
+}
+export async function analyzeVideo(src) {
+  const tsVideos = await getTsVideos();
+  if (!tsVideos)
+    return null;
+  try {
+    const srcPath = resolve(src), info = await new tsVideos.Input(srcPath).getInfo();
+    return {
+      duration: info.duration || 0,
+      width: info.width || 0,
+      height: info.height || 0,
+      frameRate: info.frameRate || 0,
+      bitrate: info.bitrate || 0,
+      codec: info.videoCodec || "",
+      audioCodec: info.audioCodec
+    };
+  } catch (error) {
+    console.warn(`[stx-media] Failed to analyze video: ${error}`);
+    return null;
+  }
+}
+export async function processVideo(src, options, config, onProgress) {
+  const tsVideos = await getTsVideos();
+  if (!tsVideos) {
+    console.warn("[stx-media] ts-videos not installed, skipping processing");
+    return { src, processed: !1 };
+  }
+  const cached = await getCachedVideoResult(src, options, config);
+  if (cached)
+    return cached;
+  try {
+    const srcPath = resolve(src);
+    if (!await fileExists(srcPath))
+      return { src, processed: !1, errors: [`Source file not found: ${src}`] };
+    const outputDir = config.outputDir || "dist/videos", baseUrl = config.baseUrl || "/videos";
+    await mkdir(outputDir, { recursive: !0 });
+    const srcHash = await hashFile(srcPath), srcBasename = basename(src, extname(src)), result = {
+      src,
+      processed: !0,
+      hash: srcHash
+    };
+    onProgress?.({ percentage: 5, stage: "analyzing" });
+    result.metadata = await analyzeVideo(srcPath) || void 0;
+    const qualitySettings = {};
+    if (options.quality)
+      qualitySettings.bitrate = getQualityBitrate(options.quality);
+    if (options.platform)
+      Object.assign(qualitySettings, getPlatformSettings(options.platform));
+    if (options.transcode)
+      Object.assign(qualitySettings, options.transcode);
+    if (Object.keys(qualitySettings).length > 0 || options.process) {
+      onProgress?.({ percentage: 10, stage: "transcoding" });
+      const outputFilename = `${srcBasename}-${srcHash}.mp4`, outputPath = join(outputDir, outputFilename);
+      try {
+        const transcodeResult = await transcodeVideo(srcPath, outputPath, qualitySettings, tsVideos, (p) => onProgress?.({ percentage: 10 + p * 0.5, stage: "transcoding" }));
+        if (transcodeResult)
+          result.transcoded = {
+            path: outputPath,
+            url: `${baseUrl}/${outputFilename}`,
+            duration: transcodeResult.duration,
+            size: transcodeResult.size,
+            video: {
+              codec: qualitySettings.codec || "h264",
+              width: transcodeResult.width,
+              height: transcodeResult.height,
+              bitrate: transcodeResult.bitrate,
+              frameRate: transcodeResult.frameRate
+            },
+            audio: transcodeResult.audioCodec ? {
+              codec: qualitySettings.audioCodec || "aac",
+              bitrate: qualitySettings.audioBitrate || 128000,
+              sampleRate: qualitySettings.sampleRate || 48000,
+              channels: qualitySettings.channels || 2
+            } : void 0
+          };
+      } catch (error) {
+        result.errors = result.errors || [];
+        result.errors.push(`Transcoding failed: ${error}`);
+      }
+    }
+    if (options.generatePoster) {
+      onProgress?.({ percentage: 65, stage: "generating-poster" });
+      const posterOpts = typeof options.generatePoster === "object" ? options.generatePoster : { timestamp: 0 }, poster = await generatePoster(srcPath, posterOpts, outputDir, baseUrl);
+      if (poster)
+        result.poster = poster;
+    }
+    if (config.thumbnails?.enabled) {
+      onProgress?.({ percentage: 70, stage: "generating-thumbnails" });
+      const thumbnails = await generateThumbnails(srcPath, config.thumbnails, outputDir, baseUrl);
+      if (thumbnails.length > 0)
+        result.thumbnails = thumbnails;
+    }
+    if (options.streaming) {
+      onProgress?.({ percentage: 80, stage: "generating-manifests" });
+      const streamConfig = typeof options.streaming === "object" ? options.streaming : config.streaming || { format: "hls" };
+      if (streamConfig.format === "hls" || streamConfig.format === void 0) {
+        const hls = await generateHLSManifest(srcPath, streamConfig.qualities || config.streaming?.defaultQualities || [], outputDir, baseUrl);
+        if (hls)
+          result.streaming = { ...result.streaming, hls };
+      }
+      if (streamConfig.format === "dash") {
+        const dash = await generateDASHManifest(srcPath, streamConfig.qualities || config.streaming?.defaultQualities || [], outputDir, baseUrl);
+        if (dash)
+          result.streaming = { ...result.streaming, dash };
+      }
+    }
+    if (options.spriteSheet)
+      onProgress?.({ percentage: 90, stage: "generating-sprite-sheet" });
+    onProgress?.({ percentage: 100, stage: "complete" });
+    await setCachedVideoResult(src, options, result, config);
+    return result;
+  } catch (error) {
+    return {
+      src,
+      processed: !1,
+      errors: [`Processing failed: ${error}`]
+    };
+  }
+}
+async function transcodeVideo(input, output, config, tsVideos, onProgress) {
+  try {
+    const result = await new tsVideos.Conversion(input, output, {
+      videoCodec: config.codec,
+      videoBitrate: config.bitrate,
+      width: config.maxWidth,
+      height: config.maxHeight,
+      frameRate: config.frameRate,
+      audioCodec: config.audioCodec,
+      audioBitrate: config.audioBitrate,
+      sampleRate: config.sampleRate,
+      channels: config.channels
+    }).run((progress) => {
+      onProgress?.(progress.percentage / 100);
+    });
+    return {
+      duration: result.duration || 0,
+      size: result.size || 0,
+      width: result.width || config.maxWidth || 0,
+      height: result.height || config.maxHeight || 0,
+      bitrate: result.bitrate || config.bitrate || 0,
+      frameRate: result.frameRate || config.frameRate || 30,
+      audioCodec: result.audioCodec
+    };
+  } catch (error) {
+    console.error(`[stx-media] Transcoding failed: ${error}`);
+    return null;
+  }
+}