@invintusmedia/tomp4 1.0.8 → 1.0.9

package/dist/tomp4.js

@@ -1,5 +1,5 @@
 /**
- * toMp4.js v1.0.8
+ * toMp4.js v1.0.9
  * Convert MPEG-TS and fMP4 to standard MP4
  * https://github.com/TVWIT/toMp4.js
  * MIT License
@@ -756,7 +756,7 @@
   toMp4.isMpegTs = isMpegTs;
   toMp4.isFmp4 = isFmp4;
   toMp4.isStandardMp4 = isStandardMp4;
-  toMp4.version = '1.0.8';
+  toMp4.version = '1.0.9';
 
   return toMp4;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@invintusmedia/tomp4",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Convert MPEG-TS, fMP4, and HLS streams to MP4 with clipping support - pure JavaScript, zero dependencies",
   "main": "src/index.js",
   "module": "src/index.js",
@@ -20,8 +20,11 @@
   "scripts": {
     "build": "node build.js",
     "dev": "npx serve . -p 3000",
-    "test": "node tests/clip.test.js",
-    "release": "npm run build && git add -A && git commit -m \"v$(node -p \"require('./package.json').version\")\" && git tag v$(node -p \"require('./package.json').version\") && git push && git push --tags",
+    "test": "npm run test:clip && npm run test:mp4",
+    "test:clip": "node tests/clip.test.js",
+    "test:mp4": "node tests/mp4-parser.test.js",
+    "test:all": "npm run test",
+    "release": "npm test && npm run build && git add -A && git commit -m \"v$(node -p \"require('./package.json').version\")\" && git tag v$(node -p \"require('./package.json').version\") && git push && git push --tags",
     "release:patch": "npm version patch --no-git-tag-version && npm run release",
     "release:minor": "npm version minor --no-git-tag-version && npm run release",
     "release:major": "npm version major --no-git-tag-version && npm run release",

package/src/index.js

@@ -37,6 +37,8 @@ import { transcode, isWebCodecsSupported } from './transcode.js';
 import { TSMuxer } from './muxers/mpegts.js';
 import { MP4Muxer } from './muxers/mp4.js';
 import { TSParser } from './parsers/mpegts.js';
+import { MP4Parser } from './parsers/mp4.js';
+import { RemoteMp4 } from './remote/index.js';
 
 /**
  * Result object returned by toMp4()
@@ -315,8 +317,15 @@ toMp4.analyze = analyzeTsData;
 toMp4.transcode = transcode;
 toMp4.isWebCodecsSupported = isWebCodecsSupported;
 
+// Parsers
+toMp4.MP4Parser = MP4Parser;
+toMp4.TSParser = TSParser;
+
+// Remote MP4 (on-demand HLS from remote MP4)
+toMp4.RemoteMp4 = RemoteMp4;
+
 // Version (injected at build time for dist, read from package.json for ESM)
-toMp4.version = '1.0.8';
+toMp4.version = '1.0.9';
 
 // Export
 export { 
@@ -336,9 +345,14 @@ export {
   HlsVariant,
   // Transcoding (browser-only)
   transcode,
+  isWebCodecsSupported,
+  // Muxers
   TSMuxer,
   MP4Muxer,
+  // Parsers
   TSParser,
-  isWebCodecsSupported
+  MP4Parser,
+  // Remote MP4 (on-demand HLS)
+  RemoteMp4
 };
 export default toMp4;

package/src/muxers/mpegts.js

@@ -85,8 +85,9 @@ export class TSMuxer {
    * @param {Uint8Array} avccData - AVCC-formatted NAL units
    * @param {boolean} isKey - Is this a keyframe
    * @param {number} pts90k - Presentation timestamp in 90kHz ticks
+   * @param {number} [dts90k] - Decode timestamp in 90kHz ticks (defaults to pts90k)
    */
-  addVideoSample(avccData, isKey, pts90k) {
+  addVideoSample(avccData, isKey, pts90k, dts90k = pts90k) {
     const nalUnits = [];
     
     // Add AUD (Access Unit Delimiter) at start of each access unit
@@ -102,20 +103,28 @@ export class TSMuxer {
     
     // Parse AVCC NALs and convert to Annex B
     let offset = 0;
-    while (offset < avccData.length - 4) {
+    let iterations = 0;
+    const maxIterations = 10000;
+    
+    while (offset + 4 <= avccData.length && iterations < maxIterations) {
+      iterations++;
       const len = (avccData[offset] << 24) | (avccData[offset + 1] << 16) | 
                   (avccData[offset + 2] << 8) | avccData[offset + 3];
       offset += 4;
-      if (len > 0 && offset + len <= avccData.length) {
-        nalUnits.push(new Uint8Array([0, 0, 0, 1]));
-        nalUnits.push(avccData.slice(offset, offset + len));
+      
+      // Safety: bail on invalid NAL length
+      if (len <= 0 || len > avccData.length - offset) {
+        break;
       }
+      
+      nalUnits.push(new Uint8Array([0, 0, 0, 1]));
+      nalUnits.push(avccData.slice(offset, offset + len));
       offset += len;
     }
     
-    // Build PES packet
+    // Build PES packet with both PTS and DTS
     const annexB = concat(nalUnits);
-    const pes = this._buildVideoPES(annexB, pts90k);
+    const pes = this._buildVideoPES(annexB, pts90k, dts90k);
     
     // Write PAT/PMT before keyframes
     if (isKey) {
@@ -130,8 +139,8 @@ export class TSMuxer {
       this._packetizePES(audioPes, 0x102, false, audio.pts, 'audio');
     }
     
-    // Packetize video PES into 188-byte TS packets
-    this._packetizePES(pes, 0x101, isKey, pts90k, 'video');
+    // Packetize video PES into 188-byte TS packets (use DTS for PCR)
+    this._packetizePES(pes, 0x101, isKey, dts90k, 'video');
   }
   
   /**
@@ -160,16 +169,32 @@ export class TSMuxer {
   
   // --- Private methods ---
   
-  _buildVideoPES(payload, pts90k) {
-    const pes = new Uint8Array(14 + payload.length);
+  _buildVideoPES(payload, pts90k, dts90k) {
+    // If PTS == DTS, only write PTS (saves 5 bytes per frame)
+    const hasDts = pts90k !== dts90k;
+    const headerLen = hasDts ? 10 : 5;
+    const pes = new Uint8Array(9 + headerLen + payload.length);
+    
     pes[0] = 0; pes[1] = 0; pes[2] = 1; // Start code
     pes[3] = 0xE0; // Stream ID (video)
     pes[4] = 0; pes[5] = 0; // Length = 0 (unbounded)
-    pes[6] = 0x80; // Flags
-    pes[7] = 0x80; // PTS present
-    pes[8] = 5; // Header length
-    this._writePTS(pes, 9, pts90k, 0x21);
-    pes.set(payload, 14);
+    pes[6] = 0x80; // Flags: data_alignment
+    
+    if (hasDts) {
+      // PTS + DTS present
+      pes[7] = 0xC0; // PTS_DTS_flags = 11
+      pes[8] = 10;   // Header length: 5 (PTS) + 5 (DTS)
+      this._writePTS(pes, 9, pts90k, 0x31);  // PTS marker = 0011
+      this._writePTS(pes, 14, dts90k, 0x11); // DTS marker = 0001
+      pes.set(payload, 19);
+    } else {
+      // PTS only
+      pes[7] = 0x80; // PTS_DTS_flags = 10
+      pes[8] = 5;    // Header length: 5 (PTS)
+      this._writePTS(pes, 9, pts90k, 0x21);  // PTS marker = 0010
+      pes.set(payload, 14);
+    }
+    
     return pes;
   }
   
@@ -220,14 +245,17 @@ export class TSMuxer {
         
         pkt[3] = 0x30 | (this.cc[cc] & 0x0F);
         pkt[4] = afLen;
-        pkt[5] = 0x50; // PCR + random_access
+        pkt[5] = 0x50; // PCR flag + random_access_indicator
+        
+        // PCR = 33-bit base (90kHz) + 6 reserved bits + 9-bit extension (27MHz)
+        // We only use the base, extension = 0
         const pcrBase = BigInt(pts90k);
         pkt[6] = Number((pcrBase >> 25n) & 0xFFn);
         pkt[7] = Number((pcrBase >> 17n) & 0xFFn);
         pkt[8] = Number((pcrBase >> 9n) & 0xFFn);
         pkt[9] = Number((pcrBase >> 1n) & 0xFFn);
-        pkt[10] = (Number(pcrBase & 1n) << 7) | 0x7E;
-        pkt[11] = 0;
+        pkt[10] = (Number(pcrBase & 1n) << 7) | 0x7E; // LSB of base + 6 reserved (111111) 
+        pkt[11] = 0; // 9-bit extension = 0
         
         pkt.set(pes.slice(offset, offset + payloadLen), 12);
         offset += payloadLen;

package/src/parsers/mp4.js

@@ -0,0 +1,691 @@
+/**
+ * MP4 Parser
+ * 
+ * Parse MP4 files to extract tracks, samples, and metadata.
+ * Works with both local data (Uint8Array) and can be extended for remote sources.
+ * 
+ * @example
+ * // Parse local MP4 data
+ * const parser = new MP4Parser(uint8ArrayData);
+ * console.log(parser.duration, parser.videoTrack, parser.audioTrack);
+ * 
+ * // Get sample table for a track
+ * const samples = parser.getVideoSamples();
+ * 
+ * // Build HLS segments
+ * const segments = parser.buildSegments(4); // 4 second segments
+ * 
+ * @module parsers/mp4
+ */
+
+// ============================================================================
+// Binary Reading Utilities
+// ============================================================================
+
+export function readUint32(data, offset) {
+  return (data[offset] << 24) | (data[offset + 1] << 16) | 
+         (data[offset + 2] << 8) | data[offset + 3];
+}
+
+export function readUint64(data, offset) {
+  // For simplicity, only handle lower 32 bits (files < 4GB)
+  return readUint32(data, offset + 4);
+}
+
+export function readInt32(data, offset) {
+  const val = readUint32(data, offset);
+  return (val & 0x80000000) ? val - 0x100000000 : val;
+}
+
+export function boxType(data, offset) {
+  return String.fromCharCode(
+    data[offset], data[offset + 1], 
+    data[offset + 2], data[offset + 3]
+  );
+}
+
+// ============================================================================
+// Box Finding
+// ============================================================================
+
+/**
+ * Find a box by type within a data range
+ * @param {Uint8Array} data - MP4 data
+ * @param {string} type - 4-character box type (e.g., 'moov', 'trak')
+ * @param {number} start - Start offset
+ * @param {number} end - End offset
+ * @returns {object|null} Box info {offset, size, headerSize} or null
+ */
+export function findBox(data, type, start = 0, end = data.length) {
+  let offset = start;
+  while (offset < end - 8) {
+    const size = readUint32(data, offset);
+    const btype = boxType(data, offset + 4);
+    
+    if (size === 0 || size > end - offset) break;
+    
+    const headerSize = size === 1 ? 16 : 8;
+    const actualSize = size === 1 ? readUint64(data, offset + 8) : size;
+    
+    if (btype === type) {
+      return { offset, size: actualSize, headerSize };
+    }
+    offset += actualSize;
+  }
+  return null;
+}
+
+/**
+ * Find all boxes of a type within a data range
+ */
+export function findAllBoxes(data, type, start = 0, end = data.length) {
+  const boxes = [];
+  let offset = start;
+  while (offset < end - 8) {
+    const size = readUint32(data, offset);
+    const btype = boxType(data, offset + 4);
+    
+    if (size === 0 || size > end - offset) break;
+    
+    const headerSize = size === 1 ? 16 : 8;
+    const actualSize = size === 1 ? readUint64(data, offset + 8) : size;
+    
+    if (btype === type) {
+      boxes.push({ offset, size: actualSize, headerSize });
+    }
+    offset += actualSize;
+  }
+  return boxes;
+}
+
+// ============================================================================
+// Sample Table Box Parsing
+// ============================================================================
+
+/**
+ * Parse stts (time-to-sample) box
+ */
+export function parseStts(data, offset) {
+  const entryCount = readUint32(data, offset + 12);
+  const entries = [];
+  let pos = offset + 16;
+  for (let i = 0; i < entryCount; i++) {
+    entries.push({
+      sampleCount: readUint32(data, pos),
+      sampleDelta: readUint32(data, pos + 4)
+    });
+    pos += 8;
+  }
+  return entries;
+}
+
+/**
+ * Parse stss (sync sample / keyframe) box
+ */
+export function parseStss(data, offset) {
+  const entryCount = readUint32(data, offset + 12);
+  const keyframes = [];
+  let pos = offset + 16;
+  for (let i = 0; i < entryCount; i++) {
+    keyframes.push(readUint32(data, pos));
+    pos += 4;
+  }
+  return keyframes;
+}
+
+/**
+ * Parse stsz (sample size) box
+ */
+export function parseStsz(data, offset) {
+  const sampleSize = readUint32(data, offset + 12);
+  const sampleCount = readUint32(data, offset + 16);
+  
+  if (sampleSize !== 0) {
+    return Array(sampleCount).fill(sampleSize);
+  }
+  
+  const sizes = [];
+  let pos = offset + 20;
+  for (let i = 0; i < sampleCount; i++) {
+    sizes.push(readUint32(data, pos));
+    pos += 4;
+  }
+  return sizes;
+}
+
+/**
+ * Parse stco (chunk offset 32-bit) box
+ */
+export function parseStco(data, offset) {
+  const entryCount = readUint32(data, offset + 12);
+  const offsets = [];
+  let pos = offset + 16;
+  for (let i = 0; i < entryCount; i++) {
+    offsets.push(readUint32(data, pos));
+    pos += 4;
+  }
+  return offsets;
+}
+
+/**
+ * Parse co64 (chunk offset 64-bit) box
+ */
+export function parseCo64(data, offset) {
+  const entryCount = readUint32(data, offset + 12);
+  const offsets = [];
+  let pos = offset + 16;
+  for (let i = 0; i < entryCount; i++) {
+    offsets.push(readUint64(data, pos));
+    pos += 8;
+  }
+  return offsets;
+}
+
+/**
+ * Parse stsc (sample-to-chunk) box
+ */
+export function parseStsc(data, offset) {
+  const entryCount = readUint32(data, offset + 12);
+  const entries = [];
+  let pos = offset + 16;
+  for (let i = 0; i < entryCount; i++) {
+    entries.push({
+      firstChunk: readUint32(data, pos),
+      samplesPerChunk: readUint32(data, pos + 4),
+      sampleDescriptionIndex: readUint32(data, pos + 8)
+    });
+    pos += 12;
+  }
+  return entries;
+}
+
+/**
+ * Parse ctts (composition time offset) box for B-frames
+ */
+export function parseCtts(data, offset) {
+  const version = data[offset + 8];
+  const entryCount = readUint32(data, offset + 12);
+  const entries = [];
+  let pos = offset + 16;
+  for (let i = 0; i < entryCount; i++) {
+    const sampleCount = readUint32(data, pos);
+    let sampleOffset;
+    if (version === 0) {
+      sampleOffset = readUint32(data, pos + 4);
+    } else {
+      // Version 1: signed offset
+      sampleOffset = readInt32(data, pos + 4);
+    }
+    entries.push({ sampleCount, sampleOffset });
+    pos += 8;
+  }
+  return entries;
+}
+
+/**
+ * Parse mdhd (media header) box
+ */
+export function parseMdhd(data, offset) {
+  const version = data[offset + 8];
+  if (version === 0) {
+    return {
+      timescale: readUint32(data, offset + 20),
+      duration: readUint32(data, offset + 24)
+    };
+  }
+  return {
+    timescale: readUint32(data, offset + 28),
+    duration: readUint64(data, offset + 32)
+  };
+}
+
+/**
+ * Parse tkhd (track header) box
+ */
+export function parseTkhd(data, offset) {
+  const version = data[offset + 8];
+  if (version === 0) {
+    return {
+      trackId: readUint32(data, offset + 20),
+      duration: readUint32(data, offset + 28),
+      width: readUint32(data, offset + 84) / 65536,
+      height: readUint32(data, offset + 88) / 65536
+    };
+  }
+  return {
+    trackId: readUint32(data, offset + 28),
+    duration: readUint64(data, offset + 36),
+    width: readUint32(data, offset + 96) / 65536,
+    height: readUint32(data, offset + 100) / 65536
+  };
+}
+
+/**
+ * Parse avcC (AVC decoder configuration) box
+ */
+export function parseAvcC(data, offset) {
+  let pos = offset + 8;
+  const configVersion = data[pos++];
+  const profile = data[pos++];
+  const profileCompat = data[pos++];
+  const level = data[pos++];
+  const lengthSizeMinusOne = data[pos++] & 0x03;
+  const numSPS = data[pos++] & 0x1F;
+  
+  const sps = [];
+  for (let i = 0; i < numSPS; i++) {
+    const spsLen = (data[pos] << 8) | data[pos + 1];
+    pos += 2;
+    sps.push(data.slice(pos, pos + spsLen));
+    pos += spsLen;
+  }
+  
+  const numPPS = data[pos++];
+  const pps = [];
+  for (let i = 0; i < numPPS; i++) {
+    const ppsLen = (data[pos] << 8) | data[pos + 1];
+    pos += 2;
+    pps.push(data.slice(pos, pos + ppsLen));
+    pos += ppsLen;
+  }
+  
+  return { 
+    profile, 
+    level, 
+    sps, 
+    pps, 
+    nalLengthSize: lengthSizeMinusOne + 1 
+  };
+}
+
+/**
+ * Parse mp4a audio sample entry for sample rate and channels
+ */
+export function parseMp4a(data, offset) {
+  const channels = (data[offset + 24] << 8) | data[offset + 25];
+  const sampleRate = (data[offset + 32] << 8) | data[offset + 33];
+  return { channels, sampleRate };
+}
+
+// ============================================================================
+// Track Analysis
+// ============================================================================
+
+/**
+ * Analyze a single track from moov data
+ */
+export function analyzeTrack(moov, trakOffset, trakSize) {
+  // Get track header
+  const tkhd = findBox(moov, 'tkhd', trakOffset + 8, trakOffset + trakSize);
+  const tkhdInfo = tkhd ? parseTkhd(moov, tkhd.offset) : { trackId: 0, width: 0, height: 0 };
+  
+  const mdia = findBox(moov, 'mdia', trakOffset + 8, trakOffset + trakSize);
+  if (!mdia) return null;
+  
+  const mdhd = findBox(moov, 'mdhd', mdia.offset + 8, mdia.offset + mdia.size);
+  const mediaInfo = mdhd ? parseMdhd(moov, mdhd.offset) : { timescale: 90000, duration: 0 };
+  
+  const hdlr = findBox(moov, 'hdlr', mdia.offset + 8, mdia.offset + mdia.size);
+  const handlerType = hdlr ? boxType(moov, hdlr.offset + 16) : 'unkn';
+  
+  const minf = findBox(moov, 'minf', mdia.offset + 8, mdia.offset + mdia.size);
+  if (!minf) return null;
+  
+  const stbl = findBox(moov, 'stbl', minf.offset + 8, minf.offset + minf.size);
+  if (!stbl) return null;
+  
+  const stblStart = stbl.offset + 8;
+  const stblEnd = stbl.offset + stbl.size;
+  
+  // Parse sample tables
+  const sttsBox = findBox(moov, 'stts', stblStart, stblEnd);
+  const stssBox = findBox(moov, 'stss', stblStart, stblEnd);
+  const stszBox = findBox(moov, 'stsz', stblStart, stblEnd);
+  const stcoBox = findBox(moov, 'stco', stblStart, stblEnd);
+  const co64Box = findBox(moov, 'co64', stblStart, stblEnd);
+  const stscBox = findBox(moov, 'stsc', stblStart, stblEnd);
+  const stsdBox = findBox(moov, 'stsd', stblStart, stblEnd);
+  const cttsBox = findBox(moov, 'ctts', stblStart, stblEnd);
+  
+  // Parse codec config
+  let codecConfig = null;
+  let audioConfig = null;
+  
+  if (stsdBox && handlerType === 'vide') {
+    const avc1 = findBox(moov, 'avc1', stsdBox.offset + 16, stsdBox.offset + stsdBox.size);
+    if (avc1) {
+      const avcC = findBox(moov, 'avcC', avc1.offset + 86, avc1.offset + avc1.size);
+      if (avcC) {
+        codecConfig = parseAvcC(moov, avcC.offset);
+      }
+    }
+  }
+  
+  if (stsdBox && handlerType === 'soun') {
+    const mp4a = findBox(moov, 'mp4a', stsdBox.offset + 16, stsdBox.offset + stsdBox.size);
+    if (mp4a) {
+      audioConfig = parseMp4a(moov, mp4a.offset);
+    }
+  }
+  
+  return {
+    trackId: tkhdInfo.trackId,
+    type: handlerType,
+    width: tkhdInfo.width,
+    height: tkhdInfo.height,
+    timescale: mediaInfo.timescale,
+    duration: mediaInfo.duration,
+    durationSeconds: mediaInfo.duration / mediaInfo.timescale,
+    stts: sttsBox ? parseStts(moov, sttsBox.offset) : [],
+    stss: stssBox ? parseStss(moov, stssBox.offset) : [],
+    stsz: stszBox ? parseStsz(moov, stszBox.offset) : [],
+    stco: stcoBox ? parseStco(moov, stcoBox.offset) : 
+          co64Box ? parseCo64(moov, co64Box.offset) : [],
+    stsc: stscBox ? parseStsc(moov, stscBox.offset) : [],
+    ctts: cttsBox ? parseCtts(moov, cttsBox.offset) : [],
+    codecConfig,
+    audioConfig
+  };
+}
+
+// ============================================================================
+// Sample Table Building
+// ============================================================================
+
+/**
+ * Build a flat sample table with byte offsets and timestamps
+ * @param {object} track - Track metadata from analyzeTrack
+ * @returns {Array} Array of sample objects
+ */
+export function buildSampleTable(track) {
+  const { stsz, stco, stsc, stts, stss, ctts, timescale } = track;
+  const samples = [];
+  
+  // Build ctts lookup (composition time offset for B-frames)
+  const cttsOffsets = [];
+  if (ctts && ctts.length > 0) {
+    for (const entry of ctts) {
+      for (let i = 0; i < entry.sampleCount; i++) {
+        cttsOffsets.push(entry.sampleOffset);
+      }
+    }
+  }
+  
+  let sampleIndex = 0;
+  let currentDts = 0;
+  let sttsEntryIndex = 0;
+  let sttsRemaining = stts[0]?.sampleCount || 0;
+  
+  for (let chunkIndex = 0; chunkIndex < stco.length; chunkIndex++) {
+    // Find samples per chunk for this chunk
+    let samplesInChunk = 1;
+    for (let i = stsc.length - 1; i >= 0; i--) {
+      if (stsc[i].firstChunk <= chunkIndex + 1) {
+        samplesInChunk = stsc[i].samplesPerChunk;
+        break;
+      }
+    }
+    
+    let chunkOffset = stco[chunkIndex];
+    
+    for (let s = 0; s < samplesInChunk && sampleIndex < stsz.length; s++) {
+      const size = stsz[sampleIndex];
+      const duration = stts[sttsEntryIndex]?.sampleDelta || 0;
+      
+      // PTS = DTS + composition offset (ctts)
+      const compositionOffset = cttsOffsets[sampleIndex] || 0;
+      const pts = Math.max(currentDts, currentDts + compositionOffset);
+      
+      samples.push({
+        index: sampleIndex,
+        offset: chunkOffset,
+        size,
+        dts: currentDts / timescale,
+        pts: pts / timescale,
+        time: pts / timescale,
+        duration: duration / timescale,
+        isKeyframe: stss.length === 0 || stss.includes(sampleIndex + 1)
+      });
+      
+      chunkOffset += size;
+      currentDts += duration;
+      sampleIndex++;
+      
+      sttsRemaining--;
+      if (sttsRemaining === 0 && sttsEntryIndex < stts.length - 1) {
+        sttsEntryIndex++;
+        sttsRemaining = stts[sttsEntryIndex].sampleCount;
+      }
+    }
+  }
+  
+  return samples;
+}
+
+/**
+ * Build HLS-style segments from video samples
+ * @param {Array} videoSamples - Video sample table
+ * @param {number} targetDuration - Target segment duration in seconds
+ * @returns {Array} Array of segment definitions
+ */
+export function buildSegments(videoSamples, targetDuration = 4) {
+  const segments = [];
+  const keyframes = videoSamples.filter(s => s.isKeyframe);
+  
+  for (let i = 0; i < keyframes.length; i++) {
+    const start = keyframes[i];
+    const end = keyframes[i + 1] || videoSamples[videoSamples.length - 1];
+    
+    const videoStart = start.index;
+    const videoEnd = end ? end.index : videoSamples.length;
+    
+    const duration = (end ? end.time : 
+      videoSamples[videoSamples.length - 1].time + 
+      videoSamples[videoSamples.length - 1].duration) - start.time;
+    
+    // Combine short segments
+    if (segments.length > 0 && 
+        segments[segments.length - 1].duration + duration < targetDuration) {
+      const prev = segments[segments.length - 1];
+      prev.videoEnd = videoEnd;
+      prev.duration += duration;
+      prev.endTime = start.time + duration;
+    } else {
+      segments.push({
+        index: segments.length,
+        startTime: start.time,
+        endTime: start.time + duration,
+        duration,
+        videoStart,
+        videoEnd
+      });
+    }
+  }
+  
+  return segments;
+}
+
+/**
+ * Calculate byte ranges needed for a set of samples
+ * @param {Array} samples - Array of samples with offset and size
+ * @param {number} maxGap - Maximum gap to coalesce (default 64KB)
+ * @returns {Array} Array of {start, end, samples} ranges
+ */
+export function calculateByteRanges(samples, maxGap = 65536) {
+  if (samples.length === 0) return [];
+  
+  const ranges = [];
+  let currentRange = {
+    start: samples[0].offset,
+    end: samples[0].offset + samples[0].size,
+    samples: [samples[0]]
+  };
+  
+  for (let i = 1; i < samples.length; i++) {
+    const sample = samples[i];
+    
+    if (sample.offset <= currentRange.end + maxGap) {
+      currentRange.end = Math.max(currentRange.end, sample.offset + sample.size);
+      currentRange.samples.push(sample);
+    } else {
+      ranges.push(currentRange);
+      currentRange = {
+        start: sample.offset,
+        end: sample.offset + sample.size,
+        samples: [sample]
+      };
+    }
+  }
+  ranges.push(currentRange);
+  
+  return ranges;
+}
+
+// ============================================================================
+// MP4Parser Class
+// ============================================================================
+
+/**
+ * MP4 Parser - Parse MP4 files to extract tracks and samples
+ */
+export class MP4Parser {
+  /**
+   * Create parser from MP4 data
+   * @param {Uint8Array} data - Complete MP4 file data
+   */
+  constructor(data) {
+    this.data = data;
+    this.moov = null;
+    this.videoTrack = null;
+    this.audioTrack = null;
+    this.videoSamples = [];
+    this.audioSamples = [];
+    
+    this._parse();
+  }
+  
+  _parse() {
+    // Find moov box
+    const moov = findBox(this.data, 'moov');
+    if (!moov) {
+      throw new Error('No moov box found - not a valid MP4 file');
+    }
+    
+    this.moov = this.data.slice(moov.offset, moov.offset + moov.size);
+    
+    // Parse tracks
+    let trackOffset = 8;
+    while (trackOffset < this.moov.length) {
+      const trak = findBox(this.moov, 'trak', trackOffset);
+      if (!trak) break;
+      
+      const track = analyzeTrack(this.moov, trak.offset, trak.size);
+      if (track) {
+        if (track.type === 'vide' && !this.videoTrack) {
+          this.videoTrack = track;
+          this.videoSamples = buildSampleTable(track);
+        } else if (track.type === 'soun' && !this.audioTrack) {
+          this.audioTrack = track;
+          this.audioSamples = buildSampleTable(track);
+        }
+      }
+      trackOffset = trak.offset + trak.size;
+    }
+    
+    if (!this.videoTrack) {
+      throw new Error('No video track found');
+    }
+  }
+  
+  /** Duration in seconds */
+  get duration() {
+    return this.videoTrack?.durationSeconds || 0;
+  }
+  
+  /** Video width */
+  get width() {
+    return this.videoTrack?.width || 0;
+  }
+  
+  /** Video height */
+  get height() {
+    return this.videoTrack?.height || 0;
+  }
+  
+  /** Whether source has audio */
+  get hasAudio() {
+    return !!this.audioTrack;
+  }
+  
+  /** Whether video has B-frames */
+  get hasBframes() {
+    return this.videoTrack?.ctts?.length > 0;
+  }
+  
+  /** Video codec config (SPS/PPS) */
+  get videoCodecConfig() {
+    return this.videoTrack?.codecConfig;
+  }
+  
+  /** Audio config (sample rate, channels) */
+  get audioCodecConfig() {
+    return this.audioTrack?.audioConfig;
+  }
+  
+  /**
+   * Get video samples
+   * @returns {Array} Video sample table
+   */
+  getVideoSamples() {
+    return this.videoSamples;
+  }
+  
+  /**
+   * Get audio samples
+   * @returns {Array} Audio sample table
+   */
+  getAudioSamples() {
+    return this.audioSamples;
+  }
+  
+  /**
+   * Build HLS-style segments
+   * @param {number} targetDuration - Target segment duration in seconds
+   * @returns {Array} Segment definitions
+   */
+  buildSegments(targetDuration = 4) {
+    return buildSegments(this.videoSamples, targetDuration);
+  }
+  
+  /**
+   * Get sample data for a range of samples
+   * @param {Array} samples - Samples to extract (must have offset and size)
+   * @returns {Array} Samples with data property added
+   */
+  getSampleData(samples) {
+    return samples.map(sample => ({
+      ...sample,
+      data: this.data.slice(sample.offset, sample.offset + sample.size)
+    }));
+  }
+  
+  /**
+   * Get parser info
+   */
+  getInfo() {
+    return {
+      duration: this.duration,
+      width: this.width,
+      height: this.height,
+      hasAudio: this.hasAudio,
+      hasBframes: this.hasBframes,
+      videoSampleCount: this.videoSamples.length,
+      audioSampleCount: this.audioSamples.length,
+      keyframeCount: this.videoTrack?.stss?.length || 
+                     this.videoSamples.filter(s => s.isKeyframe).length
+    };
+  }
+}
+
+export default MP4Parser;
+

package/src/remote/index.js

@@ -0,0 +1,418 @@
+/**
+ * Remote MP4 Parser
+ * 
+ * Fetch and parse MP4 files remotely using byte-range requests.
+ * Only downloads metadata (moov) upfront, then fetches segments on-demand.
+ * 
+ * @example
+ * import { RemoteMp4 } from 'tomp4';
+ * 
+ * const source = await RemoteMp4.fromUrl('https://example.com/video.mp4');
+ * 
+ * // Get HLS playlists
+ * const masterPlaylist = source.getMasterPlaylist();
+ * const mediaPlaylist = source.getMediaPlaylist();
+ * 
+ * // Get a segment as MPEG-TS
+ * const tsData = await source.getSegment(0);
+ * 
+ * @module remote
+ */
+
+import {
+  readUint32, boxType, findBox,
+  analyzeTrack, buildSampleTable, buildSegments, calculateByteRanges
+} from '../parsers/mp4.js';
+
+import { TSMuxer } from '../muxers/mpegts.js';
+
+// ============================================================================
+// Configuration
+// ============================================================================
+
+const DEFAULT_SEGMENT_DURATION = 4; // seconds
+const FETCH_TIMEOUT = 30000; // 30 seconds
+const MAX_HEADER_SIZE = 256 * 1024; // 256KB for initial probe
+const MAX_TAIL_SIZE = 2 * 1024 * 1024; // 2MB for moov at end
+
+// ============================================================================
+// Fetch Utilities
+// ============================================================================
+
+async function fetchWithTimeout(url, options = {}) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT);
+  
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal
+    });
+    return response;
+  } catch (err) {
+    if (err.name === 'AbortError') {
+      throw new Error(`Fetch timeout after ${FETCH_TIMEOUT}ms`);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+async function fetchRange(url, start, end) {
+  const response = await fetchWithTimeout(url, {
+    headers: { 'Range': `bytes=${start}-${end}` }
+  });
+  if (!response.ok && response.status !== 206) {
+    throw new Error(`HTTP ${response.status}`);
+  }
+  return new Uint8Array(await response.arrayBuffer());
+}
+
+async function fetchFileSize(url) {
+  const response = await fetchWithTimeout(url, { method: 'HEAD' });
+  return parseInt(response.headers.get('content-length'), 10);
+}
+
+// ============================================================================
+// ADTS Wrapper for AAC
+// ============================================================================
+
+function wrapADTS(aacData, sampleRate, channels) {
+  const sampleRateIndex = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 
+                           22050, 16000, 12000, 11025, 8000, 7350].indexOf(sampleRate);
+  const frameLength = aacData.length + 7;
+  
+  const adts = new Uint8Array(7 + aacData.length);
+  adts[0] = 0xFF;
+  adts[1] = 0xF1;
+  adts[2] = ((2 - 1) << 6) | ((sampleRateIndex < 0 ? 4 : sampleRateIndex) << 2) | ((channels >> 2) & 0x01);
+  adts[3] = ((channels & 0x03) << 6) | ((frameLength >> 11) & 0x03);
+  adts[4] = (frameLength >> 3) & 0xFF;
+  adts[5] = ((frameLength & 0x07) << 5) | 0x1F;
+  adts[6] = 0xFC;
+  adts.set(aacData, 7);
+  
+  return adts;
+}
+
+// ============================================================================
+// RemoteMp4 Class
+// ============================================================================
+
+/**
+ * Remote MP4 source with on-demand HLS segment generation
+ */
+export class RemoteMp4 {
+  /**
+   * Create a RemoteMp4 instance from a URL
+   * @param {string} url - URL to the MP4 file
+   * @param {object} options - Options
+   * @param {number} options.segmentDuration - Target segment duration (default 4s)
+   * @param {function} options.onProgress - Progress callback
+   * @returns {Promise<RemoteMp4>}
+   */
+  static async fromUrl(url, options = {}) {
+    const instance = new RemoteMp4(url, options);
+    await instance._init();
+    return instance;
+  }
+  
+  constructor(url, options = {}) {
+    this.url = url;
+    this.segmentDuration = options.segmentDuration || DEFAULT_SEGMENT_DURATION;
+    this.onProgress = options.onProgress || (() => {});
+    
+    // Populated by _init()
+    this.fileSize = 0;
+    this.moov = null;
+    this.videoTrack = null;
+    this.audioTrack = null;
+    this.videoSamples = [];
+    this.audioSamples = [];
+    this.segments = [];
+    
+    // Computed properties
+    this.duration = 0;
+    this.width = 0;
+    this.height = 0;
+    this.hasAudio = false;
+    this.hasBframes = false;
+  }
+  
+  async _init() {
+    this.onProgress('Fetching metadata...');
+    
+    // Get file size
+    this.fileSize = await fetchFileSize(this.url);
+    
+    // Find and fetch moov box
+    this.moov = await this._findMoov();
+    
+    // Parse tracks using shared parser
+    let trackOffset = 8;
+    while (trackOffset < this.moov.length) {
+      const trak = findBox(this.moov, 'trak', trackOffset);
+      if (!trak) break;
+      
+      const track = analyzeTrack(this.moov, trak.offset, trak.size);
+      if (track) {
+        if (track.type === 'vide' && !this.videoTrack) {
+          this.videoTrack = track;
+          this.videoSamples = buildSampleTable(track);
+          this.duration = track.durationSeconds;
+          this.width = track.width;
+          this.height = track.height;
+          this.hasBframes = track.ctts && track.ctts.length > 0;
+        } else if (track.type === 'soun' && !this.audioTrack) {
+          this.audioTrack = track;
+          this.audioSamples = buildSampleTable(track);
+          this.hasAudio = true;
+        }
+      }
+      trackOffset = trak.offset + trak.size;
+    }
+    
+    if (!this.videoTrack) {
+      throw new Error('No video track found');
+    }
+    
+    // Build segments
+    this.segments = buildSegments(this.videoSamples, this.segmentDuration);
+    
+    this.onProgress(`Parsed: ${this.duration.toFixed(1)}s, ${this.segments.length} segments`);
+  }
+  
+  async _findMoov() {
+    const headerSize = Math.min(MAX_HEADER_SIZE, this.fileSize);
+    const header = await fetchRange(this.url, 0, headerSize - 1);
+    
+    // Scan header for boxes
+    let offset = 0;
+    while (offset < header.length - 8) {
+      const size = readUint32(header, offset);
+      const type = boxType(header, offset + 4);
+      
+      if (size === 0 || size > this.fileSize) break;
+      
+      if (type === 'moov') {
+        // moov in header - fetch complete if needed
+        if (offset + size <= header.length) {
+          return header.slice(offset, offset + size);
+        }
+        return fetchRange(this.url, offset, offset + size - 1);
+      }
+      
+      if (type === 'mdat') {
+        // mdat at start means moov is at end
+        const moovOffset = offset + size;
+        if (moovOffset < this.fileSize) {
+          const tailSize = Math.min(MAX_TAIL_SIZE, this.fileSize - moovOffset);
+          const tail = await fetchRange(this.url, moovOffset, moovOffset + tailSize - 1);
+          const moov = findBox(tail, 'moov');
+          if (moov) {
+            if (moov.size <= tail.length) {
+              return tail.slice(moov.offset, moov.offset + moov.size);
+            }
+            return fetchRange(this.url, moovOffset + moov.offset, 
+                            moovOffset + moov.offset + moov.size - 1);
+          }
+        }
+        break;
+      }
+      
+      offset += size;
+    }
+    
+    // Try end of file as fallback
+    const tailSize = Math.min(MAX_TAIL_SIZE, this.fileSize);
+    const tail = await fetchRange(this.url, this.fileSize - tailSize, this.fileSize - 1);
+    const moov = findBox(tail, 'moov');
+    
+    if (moov) {
+      const moovStart = this.fileSize - tailSize + moov.offset;
+      return fetchRange(this.url, moovStart, moovStart + moov.size - 1);
+    }
+    
+    // Check for fragmented MP4
+    const moof = findBox(header, 'moof');
+    if (moof) {
+      throw new Error('Fragmented MP4 (fMP4) not supported');
+    }
+    
+    throw new Error('Could not find moov box');
+  }
+  
+  // ===========================================================================
+  // Public API
+  // ===========================================================================
+  
+  /**
+   * Get source information
+   */
+  getInfo() {
+    return {
+      url: this.url,
+      fileSize: this.fileSize,
+      duration: this.duration,
+      width: this.width,
+      height: this.height,
+      hasAudio: this.hasAudio,
+      hasBframes: this.hasBframes,
+      segmentCount: this.segments.length,
+      videoSampleCount: this.videoSamples.length,
+      audioSampleCount: this.audioSamples.length,
+      keyframeCount: this.videoTrack?.stss?.length || 0
+    };
+  }
+  
+  /**
+   * Get segment definitions
+   */
+  getSegments() {
+    return this.segments.map(s => ({
+      index: s.index,
+      startTime: s.startTime,
+      endTime: s.endTime,
+      duration: s.duration
+    }));
+  }
+  
+  /**
+   * Generate HLS master playlist
+   */
+  getMasterPlaylist(baseUrl = '') {
+    const bandwidth = Math.round(
+      (this.videoSamples.reduce((s, v) => s + v.size, 0) / this.duration) * 8
+    );
+    
+    const resolution = this.width && this.height ? 
+      `,RESOLUTION=${this.width}x${this.height}` : '';
+    
+    return `#EXTM3U
+#EXT-X-VERSION:3
+#EXT-X-STREAM-INF:BANDWIDTH=${bandwidth}${resolution}
+${baseUrl}playlist.m3u8
+`;
+  }
+  
+  /**
+   * Generate HLS media playlist
+   */
+  getMediaPlaylist(baseUrl = '') {
+    let playlist = `#EXTM3U
+#EXT-X-VERSION:3
+#EXT-X-TARGETDURATION:${Math.ceil(this.segmentDuration)}
+#EXT-X-MEDIA-SEQUENCE:0
+#EXT-X-PLAYLIST-TYPE:VOD
+`;
+    
+    for (const segment of this.segments) {
+      playlist += `#EXTINF:${segment.duration.toFixed(6)},\n${baseUrl}segment${segment.index}.ts\n`;
+    }
+    
+    playlist += '#EXT-X-ENDLIST\n';
+    return playlist;
+  }
+  
+  /**
+   * Get a segment as MPEG-TS data
+   * @param {number} index - Segment index
+   * @returns {Promise<Uint8Array>} MPEG-TS segment data
+   */
+  async getSegment(index) {
+    const segment = this.segments[index];
+    if (!segment) {
+      throw new Error(`Segment ${index} not found`);
+    }
+    
+    // Get samples for this segment
+    const videoSamples = this.videoSamples.slice(segment.videoStart, segment.videoEnd);
+    const audioSamples = this.audioSamples.filter(
+      s => s.time >= segment.startTime && s.time < segment.endTime
+    );
+    
+    // Fetch video data using byte ranges
+    const videoRanges = calculateByteRanges(videoSamples);
+    const videoData = await this._fetchRanges(videoRanges);
+    
+    // Map video sample data
+    const parsedVideoSamples = videoSamples.map(sample => {
+      const range = videoRanges.find(r => r.samples.includes(sample));
+      const data = videoData.get(range);
+      const relOffset = sample.offset - range.start;
+      return {
+        ...sample,
+        data: data.slice(relOffset, relOffset + sample.size)
+      };
+    });
+    
+    // Fetch and map audio data
+    let parsedAudioSamples = [];
+    if (audioSamples.length > 0) {
+      const audioRanges = calculateByteRanges(audioSamples);
+      const audioData = await this._fetchRanges(audioRanges);
+      
+      parsedAudioSamples = audioSamples.map(sample => {
+        const range = audioRanges.find(r => r.samples.includes(sample));
+        const data = audioData.get(range);
+        const relOffset = sample.offset - range.start;
+        return {
+          ...sample,
+          data: data.slice(relOffset, relOffset + sample.size)
+        };
+      });
+    }
+    
+    // Build MPEG-TS segment
+    return this._buildTsSegment(parsedVideoSamples, parsedAudioSamples);
+  }
+  
+  async _fetchRanges(ranges) {
+    const results = new Map();
+    
+    // Fetch ranges in parallel
+    await Promise.all(ranges.map(async range => {
+      const data = await fetchRange(this.url, range.start, range.end - 1);
+      results.set(range, data);
+    }));
+    
+    return results;
+  }
+  
+  _buildTsSegment(videoSamples, audioSamples) {
+    const muxer = new TSMuxer();
+    
+    if (this.videoTrack?.codecConfig) {
+      muxer.setSpsPps(
+        this.videoTrack.codecConfig.sps[0],
+        this.videoTrack.codecConfig.pps[0]
+      );
+    }
+    
+    muxer.setHasAudio(audioSamples.length > 0);
+    
+    const PTS_PER_SECOND = 90000;
+    const sampleRate = this.audioTrack?.audioConfig?.sampleRate || 44100;
+    const channels = this.audioTrack?.audioConfig?.channels || 2;
+    
+    // Add audio samples
+    for (const sample of audioSamples) {
+      const dts90k = Math.round((sample.dts ?? sample.time) * PTS_PER_SECOND);
+      const adts = wrapADTS(sample.data, sampleRate, channels);
+      muxer.addAudioSample(adts, dts90k);
+    }
+    
+    // Add video samples with PTS and DTS
+    for (const sample of videoSamples) {
+      const pts90k = Math.round((sample.pts ?? sample.time) * PTS_PER_SECOND);
+      const dts90k = Math.round((sample.dts ?? sample.time) * PTS_PER_SECOND);
+      muxer.addVideoSample(sample.data, sample.isKeyframe, pts90k, dts90k);
+    }
+    
+    muxer.flush();
+    return muxer.build();
+  }
+}
+
+export default RemoteMp4;

package/src/transcode.js

@@ -551,11 +551,9 @@ function createAvcC(sps, pps) {
 // ============================================
 
 /**
- * Transcode video using WebCodecs (browser-only)
+ * Transcode MPEG-TS video using WebCodecs (browser-only)
  * 
- * Supports both MPEG-TS and MP4 input files.
- * 
- * @param {Uint8Array} data - Input video data (MPEG-TS or MP4)
+ * @param {Uint8Array} tsData - Input MPEG-TS data
  * @param {Object} [options] - Transcode options
  * @param {number} [options.width] - Output width (default: same as input)
  * @param {number} [options.height] - Output height (default: same as input)
@@ -565,14 +563,14 @@ function createAvcC(sps, pps) {
  * @returns {Promise<Uint8Array>} - Transcoded MPEG-TS data
  * 
  * @example
- * const output = await transcode(videoData, {
+ * const output = await transcode(tsData, {
  *   width: 640,
  *   height: 360,
  *   bitrate: 1_000_000,
  *   onProgress: msg => console.log(msg)
  * });
  */
-export async function transcode(data, options = {}) {
+export async function transcode(tsData, options = {}) {
   requireWebCodecs();
   
   const log = options.onProgress || (() => {});
@@ -581,37 +579,12 @@ export async function transcode(data, options = {}) {
     keyFrameInterval = 30
   } = options;
   
-  // Detect input format and parse
-  let parser;
-  let sps = null, pps = null;
   
-  if (isMp4(data)) {
-    log('Parsing input MP4...');
-    parser = new MP4Parser();
-    parser.parse(data);
-    parser.finalize();
-    
-    // Get SPS/PPS directly from MP4 parser
-    sps = parser.sps;
-    pps = parser.pps;
-  } else if (isMpegTs(data)) {
-    log('Parsing input MPEG-TS...');
-    parser = new TSParser();
-    parser.parse(data);
-    parser.finalize();
-    
-    // Find SPS/PPS in NAL units
-    for (const au of parser.videoAccessUnits) {
-      for (const nal of au.nalUnits) {
-        const t = nal[0] & 0x1f;
-        if (t === 7 && !sps) sps = nal;
-        if (t === 8 && !pps) pps = nal;
-      }
-      if (sps && pps) break;
-    }
-  } else {
-    throw new Error('Unsupported input format. Expected MPEG-TS or MP4.');
-  }
+  // Parse input TS
+  log('Parsing input MPEG-TS...');
+  const parser = new TSParser();
+  parser.parse(tsData);
+  parser.finalize();
   
   if (!parser.videoAccessUnits || parser.videoAccessUnits.length === 0) {
     throw new Error('No video found in input');
@@ -625,6 +598,17 @@ export async function transcode(data, options = {}) {
     log(`Found ${parser.audioAccessUnits.length} audio frames (will passthrough)`);
   }
   
+  // Find SPS/PPS
+  let sps = null, pps = null;
+  for (const au of parser.videoAccessUnits) {
+    for (const nal of au.nalUnits) {
+      const t = nal[0] & 0x1f;
+      if (t === 7 && !sps) sps = nal;
+      if (t === 8 && !pps) pps = nal;
+    }
+    if (sps && pps) break;
+  }
+  
   if (!sps || !pps) {
     throw new Error('No SPS/PPS found in input');
   }