@invintusmedia/tomp4 1.0.1 → 1.0.3

package/README.md

@@ -1,7 +1,7 @@
 <div align="center">
   <div><b>toMp4</b></div>
   <div>turn streams into files</div>
-  <div><code>npm install tomp4</code></div>
+  <div><code>npm install @invintusmedia/tomp4</code></div>
 </div>
 
 &nbsp;
@@ -11,7 +11,7 @@ you've got an HLS stream, or some `.ts` segments, or fMP4 chunks.
 you want an `.mp4` file.
 
 ```js
-import toMp4 from 'tomp4'
+import toMp4 from '@invintusmedia/tomp4'
 
 const mp4 = await toMp4('https://example.com/stream.m3u8')
 mp4.download('my-video.mp4')
@@ -39,19 +39,42 @@ console.log(hls.qualities) // ['1080p', '720p', '480p']
 const mp4 = await toMp4(hls.select('720p'))
 ```
 
-### use the result
+### clip to time range
+
+```js
+// one-step: download HLS + clip (only fetches needed segments)
+const mp4 = await toMp4('https://example.com/stream.m3u8', {
+  startTime: 0,
+  endTime: 30
+})
+
+// clip existing data (snaps to keyframes)
+const mp4 = await toMp4(data, {
+  startTime: 5,
+  endTime: 15
+})
+```
+
+### analyze without converting
 
 ```js
-// download it
-mp4.download('video.mp4')
+const info = toMp4.analyze(tsData)
 
-// play it
-video.src = mp4.toURL()
+info.duration      // 99.5 (seconds)
+info.keyframes     // [{index: 0, time: 0}, {index: 150, time: 5.0}, ...]
+info.videoCodec    // "H.264/AVC"
+info.audioCodec    // "AAC"
+```
+
+### use the result
 
-// get the bytes
-mp4.data // Uint8Array
-mp4.toArrayBuffer()
-mp4.toBlob()
+```js
+mp4.download('video.mp4')   // trigger download
+video.src = mp4.toURL()     // play in video element
+mp4.data                    // Uint8Array
+mp4.toBlob()                // Blob
+mp4.toArrayBuffer()         // ArrayBuffer
+mp4.revokeURL()             // free memory
 ```
 
 &nbsp;
@@ -85,11 +108,10 @@ works in both. ~50kb minified.
 
 ```html
 <script type="module">
-  import toMp4 from './dist/tomp4.js'
+  import toMp4 from '@invintusmedia/tomp4'
 </script>
 ```
 
 &nbsp;
 
 MIT
-

package/dist/tomp4.js

@@ -1,5 +1,5 @@
 /**
- * toMp4.js v1.0.1
+ * toMp4.js v1.0.3
  * Convert MPEG-TS and fMP4 to standard MP4
  * https://github.com/TVWIT/toMp4.js
  * MIT License
@@ -1085,15 +1085,132 @@
     return STREAM_TYPES[streamType] || { name: `Unknown (0x${streamType?.toString(16)})`, supported: false };
   }
   
+  /**
+   * Check if a video access unit contains a keyframe (IDR NAL unit)
+   */
+  function isKeyframe(accessUnit) {
+    for (const nalUnit of accessUnit.nalUnits) {
+      const nalType = nalUnit[0] & 0x1F;
+      if (nalType === 5) return true; // IDR slice
+    }
+    return false;
+  }
+  
+  /**
+   * Clip access units to a time range, snapping to keyframes
+   * @param {Array} videoAUs - Video access units
+   * @param {Array} audioAUs - Audio access units  
+   * @param {number} startTime - Start time in seconds
+   * @param {number} endTime - End time in seconds
+   * @returns {object} Clipped access units and info
+   */
+  function clipAccessUnits(videoAUs, audioAUs, startTime, endTime) {
+    const PTS_PER_SECOND = 90000;
+    const startPts = startTime * PTS_PER_SECOND;
+    const endPts = endTime * PTS_PER_SECOND;
+    
+    // Find keyframe at or before startTime
+    let startIdx = 0;
+    for (let i = 0; i < videoAUs.length; i++) {
+      if (videoAUs[i].pts > startPts) break;
+      if (isKeyframe(videoAUs[i])) startIdx = i;
+    }
+    
+    // Find first frame after endTime
+    let endIdx = videoAUs.length;
+    for (let i = startIdx; i < videoAUs.length; i++) {
+      if (videoAUs[i].pts >= endPts) {
+        endIdx = i;
+        break;
+      }
+    }
+    
+    // Clip video
+    const clippedVideo = videoAUs.slice(startIdx, endIdx);
+    
+    // Get actual PTS range from clipped video
+    const actualStartPts = clippedVideo.length > 0 ? clippedVideo[0].pts : 0;
+    const actualEndPts = clippedVideo.length > 0 ? clippedVideo[clippedVideo.length - 1].pts : 0;
+    
+    // Clip audio to match video time range
+    const clippedAudio = audioAUs.filter(au => au.pts >= actualStartPts && au.pts <= actualEndPts);
+    
+    // Normalize timestamps so clip starts at 0
+    const offset = actualStartPts;
+    for (const au of clippedVideo) {
+      au.pts -= offset;
+      au.dts -= offset;
+    }
+    for (const au of clippedAudio) {
+      au.pts -= offset;
+    }
+    
+    return {
+      video: clippedVideo,
+      audio: clippedAudio,
+      actualStartTime: actualStartPts / PTS_PER_SECOND,
+      actualEndTime: actualEndPts / PTS_PER_SECOND,
+      offset
+    };
+  }
+  
   /**
    * Convert MPEG-TS data to MP4
    * 
    * @param {Uint8Array} tsData - MPEG-TS data
    * @param {object} options - Optional settings
    * @param {function} options.onProgress - Progress callback
+   * @param {number} options.startTime - Start time in seconds (snaps to nearest keyframe)
+   * @param {number} options.endTime - End time in seconds
    * @returns {Uint8Array} MP4 data
    * @throws {Error} If codecs are unsupported or no video found
    */
+  /**
+   * Analyze MPEG-TS data without converting
+   * Returns duration, keyframe positions, and stream info
+   * 
+   * @param {Uint8Array} tsData - MPEG-TS data
+   * @returns {object} Analysis results
+   */
+  function analyzeTsData(tsData) {
+    const parser = new TSParser();
+    parser.parse(tsData);
+    parser.finalize();
+    
+    const PTS_PER_SECOND = 90000;
+    
+    // Find keyframes and their timestamps
+    const keyframes = [];
+    for (let i = 0; i < parser.videoAccessUnits.length; i++) {
+      if (isKeyframe(parser.videoAccessUnits[i])) {
+        keyframes.push({
+          index: i,
+          time: parser.videoAccessUnits[i].pts / PTS_PER_SECOND
+        });
+      }
+    }
+    
+    // Calculate duration
+    const videoDuration = parser.videoPts.length > 0 
+      ? (Math.max(...parser.videoPts) - Math.min(...parser.videoPts)) / PTS_PER_SECOND
+      : 0;
+    const audioDuration = parser.audioPts.length > 0
+      ? (Math.max(...parser.audioPts) - Math.min(...parser.audioPts)) / PTS_PER_SECOND
+      : 0;
+    
+    return {
+      duration: Math.max(videoDuration, audioDuration),
+      videoFrames: parser.videoAccessUnits.length,
+      audioFrames: parser.audioAccessUnits.length,
+      keyframes,
+      keyframeCount: keyframes.length,
+      videoCodec: getCodecInfo(parser.videoStreamType).name,
+      audioCodec: getCodecInfo(parser.audioStreamType).name,
+      audioSampleRate: parser.audioSampleRate,
+      audioChannels: parser.audioChannels
+    };
+  }
+  
   function convertTsToMp4(tsData, options = {}) {
     const log = options.onProgress || (() => {});
     
@@ -1164,6 +1281,29 @@
       log(`Timestamps normalized: -${offsetMs}ms offset`);
     }
     
+    // Apply time range clipping if specified
+    if (options.startTime !== undefined || options.endTime !== undefined) {
+      const startTime = options.startTime || 0;
+      const endTime = options.endTime !== undefined ? options.endTime : Infinity;
+      
+      const clipResult = clipAccessUnits(
+        parser.videoAccessUnits,
+        parser.audioAccessUnits,
+        startTime,
+        endTime
+      );
+      
+      parser.videoAccessUnits = clipResult.video;
+      parser.audioAccessUnits = clipResult.audio;
+      
+      // Update PTS arrays to match
+      parser.videoPts = clipResult.video.map(au => au.pts);
+      parser.videoDts = clipResult.video.map(au => au.dts);
+      parser.audioPts = clipResult.audio.map(au => au.pts);
+      
+      log(`Clipped: ${clipResult.actualStartTime.toFixed(2)}s - ${clipResult.actualEndTime.toFixed(2)}s (${clipResult.video.length} video, ${clipResult.audio.length} audio frames)`);
+    }
+    
     const builder = new MP4Builder(parser);
     const { width, height } = builder.getVideoDimensions();
     log(`Dimensions: ${width}x${height}`);
@@ -1611,7 +1751,7 @@
   toMp4.isMpegTs = isMpegTs;
   toMp4.isFmp4 = isFmp4;
   toMp4.isStandardMp4 = isStandardMp4;
-  toMp4.version = '1.0.1';
+  toMp4.version = '1.0.3';
 
   return toMp4;
 });

package/package.json

@@ -1,10 +1,18 @@
 {
   "name": "@invintusmedia/tomp4",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Convert MPEG-TS and fMP4 streams to standard MP4 - pure JavaScript, zero dependencies",
-  "main": "dist/tomp4.js",
+  "main": "src/index.js",
   "module": "src/index.js",
+  "types": "src/index.d.ts",
   "type": "module",
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "require": "./dist/tomp4.js",
+      "types": "./src/index.d.ts"
+    }
+  },
   "files": [
     "src",
     "dist"

package/src/hls.js

@@ -104,16 +104,30 @@ function toAbsoluteUrl(relative, base) {
   return new URL(relative, base).href;
 }
 
+/**
+ * Represents a segment with duration info
+ */
+class HlsSegment {
+  constructor(url, duration, startTime) {
+    this.url = url;
+    this.duration = duration;
+    this.startTime = startTime;
+    this.endTime = startTime + duration;
+  }
+}
+
 /**
  * Parse an HLS playlist text
  * @param {string} text - Playlist content
  * @param {string} baseUrl - Base URL for resolving relative paths
- * @returns {{ variants: HlsVariant[], segments: string[] }}
+ * @returns {{ variants: HlsVariant[], segments: HlsSegment[] }}
  */
 function parsePlaylistText(text, baseUrl) {
   const lines = text.split('\n').map(l => l.trim());
   const variants = [];
   const segments = [];
+  let currentDuration = 0;
+  let runningTime = 0;
 
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
@@ -137,11 +151,23 @@ function parsePlaylistText(text, baseUrl) {
       }
     }
 
+    // Parse segment duration
+    if (line.startsWith('#EXTINF:')) {
+      const match = line.match(/#EXTINF:([\d.]+)/);
+      currentDuration = match ? parseFloat(match[1]) : 0;
+    }
+
     // Parse media playlist segments
     if (line && !line.startsWith('#')) {
       // It's a segment URL
       if (!lines.some(l => l.startsWith('#EXT-X-STREAM-INF'))) {
-        segments.push(toAbsoluteUrl(line, baseUrl));
+        segments.push(new HlsSegment(
+          toAbsoluteUrl(line, baseUrl),
+          currentDuration,
+          runningTime
+        ));
+        runningTime += currentDuration;
+        currentDuration = 0;
       }
     }
   }
@@ -190,6 +216,8 @@ async function parseHls(url, options = {}) {
  * @param {object} [options] - Options
  * @param {string|number} [options.quality] - 'highest', 'lowest', or bandwidth number
  * @param {number} [options.maxSegments] - Max segments to download (default: all)
+ * @param {number} [options.startTime] - Start time in seconds (downloads segments that overlap)
+ * @param {number} [options.endTime] - End time in seconds
  * @param {function} [options.onProgress] - Progress callback
  * @returns {Promise<Uint8Array>} Combined segment data
  */
@@ -229,13 +257,35 @@ async function downloadHls(source, options = {}) {
     throw new Error('No segments found in playlist');
   }
 
-  // Limit segments if specified
-  const toDownload = options.maxSegments ? segments.slice(0, options.maxSegments) : segments;
+  // Filter by time range if specified
+  let toDownload = segments;
+  const hasTimeRange = options.startTime !== undefined || options.endTime !== undefined;
+  
+  if (hasTimeRange) {
+    const startTime = options.startTime || 0;
+    const endTime = options.endTime !== undefined ? options.endTime : Infinity;
+    
+    // Find segments that overlap with the time range
+    toDownload = segments.filter(seg => seg.endTime > startTime && seg.startTime < endTime);
+    
+    if (toDownload.length > 0) {
+      const actualStart = toDownload[0].startTime;
+      const actualEnd = toDownload[toDownload.length - 1].endTime;
+      log(`Time range: ${startTime}s-${endTime}s → segments ${actualStart.toFixed(1)}s-${actualEnd.toFixed(1)}s`);
+    }
+  }
+
+  // Limit segments if specified (applied after time filtering)
+  if (options.maxSegments && toDownload.length > options.maxSegments) {
+    toDownload = toDownload.slice(0, options.maxSegments);
+  }
+  
   log(`Downloading ${toDownload.length} segment${toDownload.length > 1 ? 's' : ''}...`);
 
   // Download all segments in parallel
   const buffers = await Promise.all(
-    toDownload.map(async (url, i) => {
+    toDownload.map(async (seg, i) => {
+      const url = seg.url || seg; // Handle both HlsSegment objects and plain URLs
       const resp = await fetch(url);
       if (!resp.ok) {
         throw new Error(`Segment ${i + 1} failed: ${resp.status}`);
@@ -254,6 +304,15 @@ async function downloadHls(source, options = {}) {
   }
 
   log(`Downloaded ${(totalSize / 1024 / 1024).toFixed(2)} MB`);
+  
+  // Return with metadata for precise clipping
+  combined._hlsTimeRange = hasTimeRange ? {
+    requestedStart: options.startTime || 0,
+    requestedEnd: options.endTime,
+    actualStart: toDownload[0]?.startTime || 0,
+    actualEnd: toDownload[toDownload.length - 1]?.endTime || 0
+  } : null;
+  
   return combined;
 }
 
@@ -270,7 +329,8 @@ function isHlsUrl(url) {
 
 export { 
   HlsStream, 
-  HlsVariant, 
+  HlsVariant,
+  HlsSegment,
   parseHls, 
   downloadHls, 
   isHlsUrl,

package/src/index.d.ts

@@ -0,0 +1,135 @@
+declare module '@invintusmedia/tomp4' {
+  export interface Mp4Result {
+    /** Raw MP4 data */
+    data: Uint8Array;
+    /** Suggested filename */
+    filename: string;
+    /** Size in bytes */
+    size: number;
+    /** Human-readable size (e.g. "2.5 MB") */
+    sizeFormatted: string;
+    /** Get as Blob */
+    toBlob(): Blob;
+    /** Get as object URL for video.src */
+    toURL(): string;
+    /** Revoke the object URL to free memory */
+    revokeURL(): void;
+    /** Trigger browser download */
+    download(filename?: string): void;
+    /** Get as ArrayBuffer */
+    toArrayBuffer(): ArrayBuffer;
+  }
+
+  export interface HlsVariant {
+    url: string;
+    bandwidth: number;
+    resolution?: string;
+    width?: number;
+    height?: number;
+    codecs?: string;
+  }
+
+  export interface HlsStream {
+    masterUrl: string;
+    variants: HlsVariant[];
+    qualities: string[];
+    select(quality: string | number): HlsStream;
+    segments: string[];
+  }
+
+  export interface ToMp4Options {
+    /** Progress callback */
+    onProgress?: (message: string) => void;
+    /** Suggested filename for downloads */
+    filename?: string;
+    /** HLS quality: 'highest', 'lowest', or bandwidth number */
+    quality?: 'highest' | 'lowest' | number;
+    /** Max HLS segments to download */
+    maxSegments?: number;
+    /** Start time in seconds (snaps to nearest keyframe) */
+    startTime?: number;
+    /** End time in seconds */
+    endTime?: number;
+  }
+
+  export interface KeyframeInfo {
+    /** Frame index */
+    index: number;
+    /** Time in seconds */
+    time: number;
+  }
+
+  export interface AnalysisResult {
+    /** Total duration in seconds */
+    duration: number;
+    /** Number of video frames */
+    videoFrames: number;
+    /** Number of audio frames */
+    audioFrames: number;
+    /** Keyframe positions */
+    keyframes: KeyframeInfo[];
+    /** Number of keyframes */
+    keyframeCount: number;
+    /** Video codec name */
+    videoCodec: string;
+    /** Audio codec name */
+    audioCodec: string;
+    /** Audio sample rate */
+    audioSampleRate: number | null;
+    /** Audio channel count */
+    audioChannels: number | null;
+  }
+
+  /**
+   * Convert video to MP4
+   * @param input - URL, HLS stream, or video data
+   * @param options - Conversion options
+   */
+  function toMp4(
+    input: string | Uint8Array | ArrayBuffer | Blob | HlsStream,
+    options?: ToMp4Options
+  ): Promise<Mp4Result>;
+
+  namespace toMp4 {
+    /** Library version */
+    const version: string;
+    
+    /** Convert MPEG-TS data to MP4 */
+    function fromTs(data: Uint8Array | ArrayBuffer, options?: ToMp4Options): Mp4Result;
+    
+    /** Convert fMP4 data to MP4 */
+    function fromFmp4(data: Uint8Array | ArrayBuffer): Mp4Result;
+    
+    /** Detect format of video data */
+    function detectFormat(data: Uint8Array): 'mpegts' | 'fmp4' | 'mp4' | 'unknown';
+    
+    /** Check if data is MPEG-TS */
+    function isMpegTs(data: Uint8Array): boolean;
+    
+    /** Check if data is fMP4 */
+    function isFmp4(data: Uint8Array): boolean;
+    
+    /** Check if data is standard MP4 */
+    function isStandardMp4(data: Uint8Array): boolean;
+    
+    /** Parse HLS playlist */
+    function parseHls(url: string): Promise<HlsStream>;
+    
+    /** Download and combine HLS segments */
+    function downloadHls(
+      input: string | HlsStream,
+      options?: ToMp4Options
+    ): Promise<Uint8Array>;
+    
+    /** Check if URL is an HLS playlist */
+    function isHlsUrl(url: string): boolean;
+    
+    /** Analyze MPEG-TS data without converting */
+    function analyze(data: Uint8Array): AnalysisResult;
+  }
+
+  export default toMp4;
+  export { toMp4 };
+}
+
+

package/src/index.js

@@ -30,7 +30,7 @@
  * NOT SUPPORTED: MPEG-1/2 Video, MP3, AC-3 (require transcoding)
  */
 
-import { convertTsToMp4 } from './ts-to-mp4.js';
+import { convertTsToMp4, analyzeTsData } from './ts-to-mp4.js';
 import { convertFmp4ToMp4 } from './fmp4-to-mp4.js';
 import { parseHls, downloadHls, isHlsUrl, HlsStream, HlsVariant } from './hls.js';
 
@@ -289,8 +289,11 @@ toMp4.parseHls = parseHls;
 toMp4.downloadHls = downloadHls;
 toMp4.isHlsUrl = isHlsUrl;
 
+// Analysis utilities
+toMp4.analyze = analyzeTsData;
+
 // Version (injected at build time for dist, read from package.json for ESM)
-toMp4.version = '1.0.1';
+toMp4.version = '1.0.3';
 
 // Export
 export { 
@@ -298,6 +301,7 @@ export {
   Mp4Result, 
   convertTsToMp4, 
   convertFmp4ToMp4, 
+  analyzeTsData,
   detectFormat, 
   isMpegTs, 
   isFmp4, 

package/src/ts-to-mp4.js

@@ -1064,15 +1064,132 @@ function getCodecInfo(streamType) {
   return STREAM_TYPES[streamType] || { name: `Unknown (0x${streamType?.toString(16)})`, supported: false };
 }
 
+/**
+ * Check if a video access unit contains a keyframe (IDR NAL unit)
+ */
+function isKeyframe(accessUnit) {
+  for (const nalUnit of accessUnit.nalUnits) {
+    const nalType = nalUnit[0] & 0x1F;
+    if (nalType === 5) return true; // IDR slice
+  }
+  return false;
+}
+
+/**
+ * Clip access units to a time range, snapping to keyframes
+ * @param {Array} videoAUs - Video access units
+ * @param {Array} audioAUs - Audio access units  
+ * @param {number} startTime - Start time in seconds
+ * @param {number} endTime - End time in seconds
+ * @returns {object} Clipped access units and info
+ */
+function clipAccessUnits(videoAUs, audioAUs, startTime, endTime) {
+  const PTS_PER_SECOND = 90000;
+  const startPts = startTime * PTS_PER_SECOND;
+  const endPts = endTime * PTS_PER_SECOND;
+  
+  // Find keyframe at or before startTime
+  let startIdx = 0;
+  for (let i = 0; i < videoAUs.length; i++) {
+    if (videoAUs[i].pts > startPts) break;
+    if (isKeyframe(videoAUs[i])) startIdx = i;
+  }
+  
+  // Find first frame after endTime
+  let endIdx = videoAUs.length;
+  for (let i = startIdx; i < videoAUs.length; i++) {
+    if (videoAUs[i].pts >= endPts) {
+      endIdx = i;
+      break;
+    }
+  }
+  
+  // Clip video
+  const clippedVideo = videoAUs.slice(startIdx, endIdx);
+  
+  // Get actual PTS range from clipped video
+  const actualStartPts = clippedVideo.length > 0 ? clippedVideo[0].pts : 0;
+  const actualEndPts = clippedVideo.length > 0 ? clippedVideo[clippedVideo.length - 1].pts : 0;
+  
+  // Clip audio to match video time range
+  const clippedAudio = audioAUs.filter(au => au.pts >= actualStartPts && au.pts <= actualEndPts);
+  
+  // Normalize timestamps so clip starts at 0
+  const offset = actualStartPts;
+  for (const au of clippedVideo) {
+    au.pts -= offset;
+    au.dts -= offset;
+  }
+  for (const au of clippedAudio) {
+    au.pts -= offset;
+  }
+  
+  return {
+    video: clippedVideo,
+    audio: clippedAudio,
+    actualStartTime: actualStartPts / PTS_PER_SECOND,
+    actualEndTime: actualEndPts / PTS_PER_SECOND,
+    offset
+  };
+}
+
 /**
  * Convert MPEG-TS data to MP4
  * 
  * @param {Uint8Array} tsData - MPEG-TS data
  * @param {object} options - Optional settings
  * @param {function} options.onProgress - Progress callback
+ * @param {number} options.startTime - Start time in seconds (snaps to nearest keyframe)
+ * @param {number} options.endTime - End time in seconds
  * @returns {Uint8Array} MP4 data
  * @throws {Error} If codecs are unsupported or no video found
  */
+/**
+ * Analyze MPEG-TS data without converting
+ * Returns duration, keyframe positions, and stream info
+ * 
+ * @param {Uint8Array} tsData - MPEG-TS data
+ * @returns {object} Analysis results
+ */
+export function analyzeTsData(tsData) {
+  const parser = new TSParser();
+  parser.parse(tsData);
+  parser.finalize();
+  
+  const PTS_PER_SECOND = 90000;
+  
+  // Find keyframes and their timestamps
+  const keyframes = [];
+  for (let i = 0; i < parser.videoAccessUnits.length; i++) {
+    if (isKeyframe(parser.videoAccessUnits[i])) {
+      keyframes.push({
+        index: i,
+        time: parser.videoAccessUnits[i].pts / PTS_PER_SECOND
+      });
+    }
+  }
+  
+  // Calculate duration
+  const videoDuration = parser.videoPts.length > 0 
+    ? (Math.max(...parser.videoPts) - Math.min(...parser.videoPts)) / PTS_PER_SECOND
+    : 0;
+  const audioDuration = parser.audioPts.length > 0
+    ? (Math.max(...parser.audioPts) - Math.min(...parser.audioPts)) / PTS_PER_SECOND
+    : 0;
+  
+  return {
+    duration: Math.max(videoDuration, audioDuration),
+    videoFrames: parser.videoAccessUnits.length,
+    audioFrames: parser.audioAccessUnits.length,
+    keyframes,
+    keyframeCount: keyframes.length,
+    videoCodec: getCodecInfo(parser.videoStreamType).name,
+    audioCodec: getCodecInfo(parser.audioStreamType).name,
+    audioSampleRate: parser.audioSampleRate,
+    audioChannels: parser.audioChannels
+  };
+}
+
 export function convertTsToMp4(tsData, options = {}) {
   const log = options.onProgress || (() => {});
   
@@ -1143,6 +1260,29 @@ export function convertTsToMp4(tsData, options = {}) {
     log(`Timestamps normalized: -${offsetMs}ms offset`);
   }
   
+  // Apply time range clipping if specified
+  if (options.startTime !== undefined || options.endTime !== undefined) {
+    const startTime = options.startTime || 0;
+    const endTime = options.endTime !== undefined ? options.endTime : Infinity;
+    
+    const clipResult = clipAccessUnits(
+      parser.videoAccessUnits,
+      parser.audioAccessUnits,
+      startTime,
+      endTime
+    );
+    
+    parser.videoAccessUnits = clipResult.video;
+    parser.audioAccessUnits = clipResult.audio;
+    
+    // Update PTS arrays to match
+    parser.videoPts = clipResult.video.map(au => au.pts);
+    parser.videoDts = clipResult.video.map(au => au.dts);
+    parser.audioPts = clipResult.audio.map(au => au.pts);
+    
+    log(`Clipped: ${clipResult.actualStartTime.toFixed(2)}s - ${clipResult.actualEndTime.toFixed(2)}s (${clipResult.video.length} video, ${clipResult.audio.length} audio frames)`);
+  }
+  
   const builder = new MP4Builder(parser);
   const { width, height } = builder.getVideoDimensions();
   log(`Dimensions: ${width}x${height}`);