@invintusmedia/tomp4 1.0.8 → 1.1.0

package/src/fmp4/utils.js

@@ -0,0 +1,201 @@
+/**
+ * fMP4 Box Utilities
+ * 
+ * Shared utilities for parsing and creating MP4 boxes
+ * Used by both converter and stitcher modules
+ * 
+ * @module fmp4/utils
+ */
+
+// ============================================
+// Box Parsing
+// ============================================
+
+/**
+ * Parse top-level or nested boxes from MP4 data
+ * @param {Uint8Array} data - Data buffer
+ * @param {number} offset - Start offset
+ * @param {number} end - End offset
+ * @returns {Array<{type: string, offset: number, size: number, data: Uint8Array}>}
+ */
+export function parseBoxes(data, offset = 0, end = data.byteLength) {
+    const boxes = [];
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    while (offset < end) {
+        if (offset + 8 > end) break;
+        const size = view.getUint32(offset);
+        const type = String.fromCharCode(data[offset + 4], data[offset + 5], data[offset + 6], data[offset + 7]);
+        if (size === 0 || size < 8) break;
+        boxes.push({ type, offset, size, data: data.subarray(offset, offset + size) });
+        offset += size;
+    }
+    return boxes;
+}
+
+/**
+ * Find a box by type in an array of boxes
+ * @param {Array} boxes - Array of parsed boxes
+ * @param {string} type - 4-character box type
+ * @returns {object|null} Box object or null
+ */
+export function findBox(boxes, type) {
+    for (const box of boxes) if (box.type === type) return box;
+    return null;
+}
+
+/**
+ * Parse child boxes within a container box
+ * @param {object} box - Parent box
+ * @param {number} headerSize - Header size (8 for regular, 12 for fullbox)
+ * @returns {Array} Array of child boxes
+ */
+export function parseChildBoxes(box, headerSize = 8) {
+    return parseBoxes(box.data, headerSize, box.size);
+}
+
+/**
+ * Create an MP4 box with the given type and payloads
+ * @param {string} type - 4-character box type
+ * @param {...Uint8Array} payloads - Box content
+ * @returns {Uint8Array} Complete box
+ */
+export function createBox(type, ...payloads) {
+    let size = 8;
+    for (const p of payloads) size += p.byteLength;
+    const result = new Uint8Array(size);
+    const view = new DataView(result.buffer);
+    view.setUint32(0, size);
+    result[4] = type.charCodeAt(0);
+    result[5] = type.charCodeAt(1);
+    result[6] = type.charCodeAt(2);
+    result[7] = type.charCodeAt(3);
+    let offset = 8;
+    for (const p of payloads) {
+        result.set(p, offset);
+        offset += p.byteLength;
+    }
+    return result;
+}
+
+// ============================================
+// Fragment Box Parsing
+// ============================================
+
+/**
+ * Parse tfhd (track fragment header) box
+ * Extracts track ID and default sample values
+ * @param {Uint8Array} tfhdData - tfhd box data
+ * @returns {{trackId: number, defaultSampleDuration: number, defaultSampleSize: number, defaultSampleFlags: number}}
+ */
+export function parseTfhd(tfhdData) {
+    const view = new DataView(tfhdData.buffer, tfhdData.byteOffset, tfhdData.byteLength);
+    const flags = (tfhdData[9] << 16) | (tfhdData[10] << 8) | tfhdData[11];
+    const trackId = view.getUint32(12);
+    let offset = 16;
+    let defaultSampleDuration = 0, defaultSampleSize = 0, defaultSampleFlags = 0;
+
+    if (flags & 0x1) offset += 8;  // base-data-offset
+    if (flags & 0x2) offset += 4;  // sample-description-index
+    if (flags & 0x8) { defaultSampleDuration = view.getUint32(offset); offset += 4; }
+    if (flags & 0x10) { defaultSampleSize = view.getUint32(offset); offset += 4; }
+    if (flags & 0x20) { defaultSampleFlags = view.getUint32(offset); offset += 4; }
+
+    return { trackId, defaultSampleDuration, defaultSampleSize, defaultSampleFlags };
+}
+
+/**
+ * Parse tfdt (track fragment decode time) box
+ * @param {Uint8Array} tfdtData - tfdt box data
+ * @returns {number} Base media decode time
+ */
+export function parseTfdt(tfdtData) {
+    const view = new DataView(tfdtData.buffer, tfdtData.byteOffset, tfdtData.byteLength);
+    const version = tfdtData[8];
+    if (version === 1) {
+        return Number(view.getBigUint64(12));
+    }
+    return view.getUint32(12);
+}
+
+/**
+ * Parse trun (track run) box
+ * @param {Uint8Array} trunData - trun box data
+ * @param {{defaultSampleDuration?: number, defaultSampleSize?: number, defaultSampleFlags?: number}} defaults - Default values from tfhd
+ * @returns {{samples: Array, dataOffset: number, flags: number}}
+ */
+export function parseTrun(trunData, defaults = {}) {
+    const view = new DataView(trunData.buffer, trunData.byteOffset, trunData.byteLength);
+    const version = trunData[8];
+    const flags = (trunData[9] << 16) | (trunData[10] << 8) | trunData[11];
+    const sampleCount = view.getUint32(12);
+    let offset = 16;
+    let dataOffset = 0;
+    let firstSampleFlags = null;
+
+    if (flags & 0x1) { dataOffset = view.getInt32(offset); offset += 4; }
+    if (flags & 0x4) { firstSampleFlags = view.getUint32(offset); offset += 4; }
+
+    const samples = [];
+    for (let i = 0; i < sampleCount; i++) {
+        const sample = {
+            duration: defaults.defaultSampleDuration || 0,
+            size: defaults.defaultSampleSize || 0,
+            flags: (i === 0 && firstSampleFlags !== null) ? firstSampleFlags : (defaults.defaultSampleFlags || 0),
+            compositionTimeOffset: 0
+        };
+        if (flags & 0x100) { sample.duration = view.getUint32(offset); offset += 4; }
+        if (flags & 0x200) { sample.size = view.getUint32(offset); offset += 4; }
+        if (flags & 0x400) { sample.flags = view.getUint32(offset); offset += 4; }
+        if (flags & 0x800) {
+            sample.compositionTimeOffset = version === 0 ? view.getUint32(offset) : view.getInt32(offset);
+            offset += 4;
+        }
+        samples.push(sample);
+    }
+
+    return { samples, dataOffset, flags };
+}
+
+// ============================================
+// Track ID Extraction
+// ============================================
+
+/**
+ * Extract track IDs from moov box
+ * @param {object} moovBox - Parsed moov box
+ * @returns {number[]} Array of track IDs
+ */
+export function extractTrackIds(moovBox) {
+    const trackIds = [];
+    const moovChildren = parseChildBoxes(moovBox);
+    for (const child of moovChildren) {
+        if (child.type === 'trak') {
+            const trakChildren = parseChildBoxes(child);
+            for (const tc of trakChildren) {
+                if (tc.type === 'tkhd') {
+                    const view = new DataView(tc.data.buffer, tc.data.byteOffset, tc.data.byteLength);
+                    const version = tc.data[8];
+                    trackIds.push(version === 0 ? view.getUint32(20) : view.getUint32(28));
+                }
+            }
+        }
+    }
+    return trackIds;
+}
+
+/**
+ * Extract movie timescale from mvhd box
+ * @param {object} moovBox - Parsed moov box
+ * @returns {number} Movie timescale (default: 1000)
+ */
+export function getMovieTimescale(moovBox) {
+    const moovChildren = parseChildBoxes(moovBox);
+    for (const child of moovChildren) {
+        if (child.type === 'mvhd') {
+            const view = new DataView(child.data.buffer, child.data.byteOffset, child.data.byteLength);
+            const version = child.data[8];
+            return version === 0 ? view.getUint32(20) : view.getUint32(28);
+        }
+    }
+    return 1000;
+}

package/src/index.js

@@ -31,12 +31,15 @@
  */
 
 import { convertTsToMp4, analyzeTsData } from './ts-to-mp4.js';
-import { convertFmp4ToMp4 } from './fmp4-to-mp4.js';
+import { convertFmp4ToMp4, stitchFmp4 } from './fmp4/index.js';
+import { stitchTs, concatTs } from './mpegts/index.js';
 import { parseHls, downloadHls, isHlsUrl, HlsStream, HlsVariant } from './hls.js';
 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()
@@ -146,7 +149,7 @@ function isStandardMp4(data) {
   while (offset + 8 <= data.length) {
     const size = view.getUint32(offset);
     if (size < 8) break;
-    const boxType = String.fromCharCode(data[offset+4], data[offset+5], data[offset+6], data[offset+7]);
+    const boxType = String.fromCharCode(data[offset + 4], data[offset + 5], data[offset + 6], data[offset + 7]);
     if (boxType === 'moov') hasMoov = true;
     if (boxType === 'moof') hasMoof = true;
     offset += size;
@@ -168,7 +171,7 @@ function detectFormat(data) {
 function convertData(data, options = {}) {
   const uint8 = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
   const format = detectFormat(uint8);
-  
+
   switch (format) {
     case 'mpegts':
       return convertTsToMp4(uint8, options);
@@ -215,15 +218,15 @@ function convertData(data, options = {}) {
 async function toMp4(input, options = {}) {
   let data;
   let filename = options.filename || 'video.mp4';
-  const log = options.onProgress || (() => {});
-  
+  const log = options.onProgress || (() => { });
+
   // Handle HlsStream object
   if (input instanceof HlsStream) {
     if (!options.filename) {
       const urlPart = (input.masterUrl || '').split('/').pop()?.split('?')[0];
       filename = urlPart ? urlPart.replace('.m3u8', '.mp4') : 'video.mp4';
     }
-    data = await downloadHls(input, { 
+    data = await downloadHls(input, {
       ...options,
       quality: options.quality || 'highest'
     });
@@ -248,7 +251,7 @@ async function toMp4(input, options = {}) {
         throw new Error(`Failed to fetch: ${response.status} ${response.statusText}`);
       }
       data = new Uint8Array(await response.arrayBuffer());
-      
+
       if (!options.filename) {
         const urlFilename = input.split('/').pop()?.split('?')[0];
         if (urlFilename) {
@@ -272,7 +275,7 @@ async function toMp4(input, options = {}) {
   else {
     throw new Error('Input must be a URL string, HlsStream, Uint8Array, ArrayBuffer, or Blob');
   }
-  
+
   // Adjust clip times if we downloaded HLS with a time range
   // The downloaded segments have been normalized to start at 0,
   // so we need to adjust the requested clip times accordingly
@@ -287,17 +290,20 @@ async function toMp4(input, options = {}) {
     }
     log(`Adjusted clip: ${convertOptions.startTime?.toFixed(2) || 0}s - ${convertOptions.endTime?.toFixed(2) || '∞'}s (offset: -${segmentStart.toFixed(2)}s)`);
   }
-  
+
   // Convert
   log('Converting...');
   const mp4Data = convertData(data, convertOptions);
-  
+
   return new Mp4Result(mp4Data, filename);
 }
 
 // Attach utilities to main function
 toMp4.fromTs = (data, options) => new Mp4Result(convertTsToMp4(data instanceof ArrayBuffer ? new Uint8Array(data) : data, options));
 toMp4.fromFmp4 = (data) => new Mp4Result(convertFmp4ToMp4(data instanceof ArrayBuffer ? new Uint8Array(data) : data));
+toMp4.stitchFmp4 = (segments, options) => new Mp4Result(stitchFmp4(segments, options));
+toMp4.stitchTs = (segments) => new Mp4Result(stitchTs(segments));
+toMp4.concatTs = concatTs;
 toMp4.detectFormat = detectFormat;
 toMp4.isMpegTs = isMpegTs;
 toMp4.isFmp4 = isFmp4;
@@ -315,19 +321,29 @@ 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.1.0';
 
 // Export
-export { 
-  toMp4, 
-  Mp4Result, 
-  convertTsToMp4, 
-  convertFmp4ToMp4, 
+export {
+  toMp4,
+  Mp4Result,
+  convertTsToMp4,
+  convertFmp4ToMp4,
+  stitchFmp4,
+  stitchTs,
+  concatTs,
   analyzeTsData,
-  detectFormat, 
-  isMpegTs, 
-  isFmp4, 
+  detectFormat,
+  isMpegTs,
+  isFmp4,
   isStandardMp4,
   parseHls,
   downloadHls,
@@ -336,9 +352,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/mpegts/index.js

@@ -0,0 +1,7 @@
+/**
+ * MPEG-TS Stitching Module
+ * Combine multiple MPEG-TS segments into MP4 or continuous TS
+ */
+
+export { stitchTs, concatTs, parseAndCombineSegments, isKeyframe, extractSpsPps } from './stitcher.js';
+export { default } from './stitcher.js';

package/src/mpegts/stitcher.js

@@ -0,0 +1,251 @@
+/**
+ * MPEG-TS Segment Stitching
+ * Combine multiple MPEG-TS segments into a single MP4 or continuous TS stream
+ * Pure JavaScript - no dependencies
+ */
+
+import { TSParser } from '../parsers/mpegts.js';
+import { MP4Muxer } from '../muxers/mp4.js';
+import { TSMuxer } from '../muxers/mpegts.js';
+
+// ============================================
+// Utilities
+// ============================================
+
+/**
+ * Normalize input to Uint8Array
+ */
+function normalizeInput(input) {
+  if (input instanceof ArrayBuffer) {
+    return new Uint8Array(input);
+  }
+  return input;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Calculate segment duration from timestamps
+ * Returns duration in PTS ticks (90kHz)
+ */
+function getSegmentDuration(timestamps) {
+  if (!timestamps || timestamps.length < 2) return 0;
+
+  const first = timestamps[0];
+  const last = timestamps[timestamps.length - 1];
+
+  // Estimate last frame duration as average
+  const avgDuration = (last - first) / (timestamps.length - 1);
+
+  return Math.round(last - first + avgDuration);
+}
+
+/**
+ * Build ADTS header for AAC frame
+ * @param {number} dataLength - Length of AAC data (without header)
+ * @param {number} sampleRate - Audio sample rate
+ * @param {number} channels - Number of audio channels
+ * @returns {Uint8Array} 7-byte ADTS header
+ */
+function buildAdtsHeader(dataLength, sampleRate, channels) {
+  const SAMPLE_RATES = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
+  const samplingFreqIndex = SAMPLE_RATES.indexOf(sampleRate);
+  const freqIndex = samplingFreqIndex >= 0 ? samplingFreqIndex : 3; // Default to 48000
+
+  const frameLength = dataLength + 7; // ADTS header is 7 bytes
+
+  const header = new Uint8Array(7);
+  header[0] = 0xFF; // Sync word
+  header[1] = 0xF1; // MPEG-4, Layer 0, no CRC
+  header[2] = (1 << 6) | (freqIndex << 2) | ((channels >> 2) & 0x01); // AAC-LC, freq index, channel config high bit
+  header[3] = ((channels & 0x03) << 6) | ((frameLength >> 11) & 0x03);
+  header[4] = (frameLength >> 3) & 0xFF;
+  header[5] = ((frameLength & 0x07) << 5) | 0x1F;
+  header[6] = 0xFC;
+
+  return header;
+}
+
+/**
+ * Extract SPS and PPS from video access units
+ */
+function extractSpsPps(videoAccessUnits) {
+  let sps = null;
+  let pps = null;
+
+  for (const au of videoAccessUnits) {
+    for (const nalUnit of au.nalUnits) {
+      const nalType = nalUnit[0] & 0x1F;
+      if (nalType === 7 && !sps) sps = nalUnit;
+      if (nalType === 8 && !pps) pps = nalUnit;
+      if (sps && pps) return { sps, pps };
+    }
+  }
+
+  return { sps, pps };
+}
+
+// ============================================
+// Core Parsing Logic
+// ============================================
+
+/**
+ * Parse multiple TS segments and combine with continuous timestamps
+ *
+ * @param {Uint8Array[]} segments - Array of TS segment data
+ * @returns {object} Combined parser-like object compatible with MP4Muxer
+ */
+function parseAndCombineSegments(segments) {
+  if (!segments || segments.length === 0) {
+    throw new Error('stitchTs: At least one segment is required');
+  }
+
+  let runningVideoPts = 0;
+  let runningAudioPts = 0;
+
+  const combined = {
+    videoAccessUnits: [],
+    audioAccessUnits: [],
+    videoPts: [],
+    videoDts: [],
+    audioPts: [],
+    // Metadata from first segment with data
+    audioSampleRate: null,
+    audioChannels: null,
+    videoStreamType: null,
+    audioStreamType: null
+  };
+
+  for (let i = 0; i < segments.length; i++) {
+    const segmentData = normalizeInput(segments[i]);
+
+    const parser = new TSParser();
+    parser.parse(segmentData);
+    parser.finalize();
+
+    // Skip empty segments
+    if (parser.videoAccessUnits.length === 0 && parser.audioAccessUnits.length === 0) {
+      continue;
+    }
+
+    // Capture metadata from first segment with data
+    if (combined.audioSampleRate === null && parser.audioSampleRate) {
+      combined.audioSampleRate = parser.audioSampleRate;
+      combined.audioChannels = parser.audioChannels;
+    }
+    if (combined.videoStreamType === null && parser.videoStreamType) {
+      combined.videoStreamType = parser.videoStreamType;
+    }
+    if (combined.audioStreamType === null && parser.audioStreamType) {
+      combined.audioStreamType = parser.audioStreamType;
+    }
+
+    // Calculate this segment's duration for next offset
+    const segmentVideoDuration = getSegmentDuration(parser.videoDts);
+    const segmentAudioDuration = getSegmentDuration(parser.audioPts);
+
+    // Offset and append video access units
+    for (const au of parser.videoAccessUnits) {
+      combined.videoAccessUnits.push({
+        nalUnits: au.nalUnits,
+        pts: au.pts + runningVideoPts,
+        dts: au.dts + runningVideoPts
+      });
+      combined.videoPts.push(au.pts + runningVideoPts);
+      combined.videoDts.push(au.dts + runningVideoPts);
+    }
+
+    // Offset and append audio access units
+    for (const au of parser.audioAccessUnits) {
+      combined.audioAccessUnits.push({
+        data: au.data,
+        pts: au.pts + runningAudioPts
+      });
+      combined.audioPts.push(au.pts + runningAudioPts);
+    }
+
+    // Advance running offsets for next segment
+    runningVideoPts += segmentVideoDuration;
+    runningAudioPts += segmentAudioDuration;
+  }
+
+  if (combined.videoAccessUnits.length === 0) {
+    throw new Error('stitchTs: No video frames found in any segment');
+  }
+
+  return combined;
+}
+
+// ============================================
+// Public API
+// ============================================
+
+/**
+ * Stitch multiple MPEG-TS segments into a single standard MP4
+ *
+ * @param {(Uint8Array | ArrayBuffer)[]} segments - Array of TS segment data
+ * @returns {Uint8Array} MP4 data
+ *
+ * @example
+ * const mp4Data = stitchTs([segment1, segment2, segment3]);
+ */
+export function stitchTs(segments) {
+  const combined = parseAndCombineSegments(segments);
+  const muxer = new MP4Muxer(combined);
+  return muxer.build();
+}
+
+/**
+ * Concatenate multiple MPEG-TS segments into a single continuous TS stream
+ *
+ * @param {(Uint8Array | ArrayBuffer)[]} segments - Array of TS segment data
+ * @returns {Uint8Array} Combined MPEG-TS data with continuous timestamps
+ *
+ * @example
+ * const tsData = concatTs([segment1, segment2, segment3]);
+ */
+export function concatTs(segments) {
+  const combined = parseAndCombineSegments(segments);
+  const { sps, pps } = extractSpsPps(combined.videoAccessUnits);
+
+  const muxer = new TSMuxer();
+
+  if (sps && pps) {
+    muxer.setSpsPps(sps, pps);
+  }
+  muxer.setHasAudio(combined.audioAccessUnits.length > 0);
+
+  // Queue all audio samples (need to wrap raw AAC in ADTS)
+  const sampleRate = combined.audioSampleRate || 48000;
+  const channels = combined.audioChannels || 2;
+
+  for (const au of combined.audioAccessUnits) {
+    // Build ADTS frame from raw AAC data
+    const header = buildAdtsHeader(au.data.length, sampleRate, channels);
+    const adtsFrame = new Uint8Array(header.length + au.data.length);
+    adtsFrame.set(header, 0);
+    adtsFrame.set(au.data, header.length);
+    muxer.addAudioSample(adtsFrame, au.pts);
+  }
+
+  // Add video samples using NAL units directly
+  for (const au of combined.videoAccessUnits) {
+    const isKey = isKeyframe(au);
+    muxer.addVideoNalUnits(au.nalUnits, isKey, au.pts, au.dts);
+  }
+
+  muxer.flush();
+  return muxer.build();
+}
+
+export { parseAndCombineSegments, isKeyframe, extractSpsPps };
+export default stitchTs;