@h3l1os/mp4vault 2.0.0

package/src/jspack.js

@@ -0,0 +1,319 @@
+/* eslint-disable */
+// https://github.com/AndreasAntener/node-jspack
+/* !
+ *  Copyright © 2008 Fair Oaks Labs, Inc.
+ *  All rights reserved.
+ */
+
+// Utility object:  Encode / Decode C-style binary primitives to / from octet arrays
+function JSPack() {
+  // Module-level (private) variables
+  var el;
+  var bBE = false;
+  var m = this;
+
+  // Raw byte arrays
+  m._DeArray = function (a, p, l) {
+    return [a.slice(p, p + l)];
+  };
+
+  m._EnArray = function (a, p, l, v) {
+    for (var i = 0; i < l; a[p + i] = v[i] ? v[i] : 0, i++) { }
+  };
+
+  // ASCII characters
+  m._DeChar = function (a, p) {
+    return String.fromCharCode(a[p]);
+  };
+
+  m._EnChar = function (a, p, v) {
+    a[p] = v.charCodeAt(0);
+  };
+
+  // Little-endian (un)signed N-byte integers
+  m._DeInt = function (a, p) {
+    var lsb = bBE ? (el.len - 1) : 0;
+    var nsb = bBE ? -1 : 1;
+    var stop = lsb + nsb * el.len;
+    var rv, i, f;
+    for (rv = 0, i = lsb, f = 1; i != stop; rv += (a[p + i] * f), i += nsb, f *= 256) { }
+    if (el.bSigned && (rv & Math.pow(2, el.len * 8 - 1))) { rv -= Math.pow(2, el.len * 8); }
+    return rv;
+  };
+
+  m._EnInt = function (a, p, v) {
+    var lsb = bBE ? (el.len - 1) : 0;
+    var nsb = bBE ? -1 : 1;
+    var stop = lsb + nsb * el.len;
+    var i;
+    v = (v < el.min) ? el.min : (v > el.max) ? el.max : v;
+    for (i = lsb; i != stop; a[p + i] = v & 0xff, i += nsb, v >>= 8) { }
+  };
+
+  // ASCII character strings
+  m._DeString = function (a, p, l) {
+    for (var rv = new Array(l), i = 0; i < l; rv[i] = String.fromCharCode(a[p + i]), i++) { }
+    return rv.join('');
+  };
+  m._EnString = function (a, p, l, v) {
+
+    for (var t, i = 0; i < l; a[p + i] = (t = v.charCodeAt(i)) ? t : 0, i++) { }
+  };
+
+  // Little-endian N-bit IEEE 754 floating point
+  m._De754 = function (a, p) {
+    var s, e, m, i, d, nBits, mLen, eLen, eBias, eMax;
+    mLen = el.mLen, eLen = el.len * 8 - el.mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1;
+
+    i = bBE ? 0 : (el.len - 1); d = bBE ? 1 : -1; s = a[p + i]; i += d; nBits = -7;
+    for (e = s & ((1 << (-nBits)) - 1), s >>= (-nBits), nBits += eLen;
+     nBits > 0; e = e * 256 + a[p + i], i += d, nBits -= 8) { }
+    for (m = e & ((1 << (-nBits)) - 1), e >>= (-nBits), nBits += mLen; nBits > 0;
+      m = m * 256 + a[p + i], i += d, nBits -= 8) { }
+
+    switch (e) {
+
+      case 0:
+        // Zero, or denormalized number
+        e = 1 - eBias;
+        break;
+      case eMax:
+        // NaN, or +/-Infinity
+        return m ? NaN : ((s ? -1 : 1) * Infinity);
+      default:
+        // Normalized number
+        m = m + Math.pow(2, mLen);
+        e = e - eBias;
+        break;
+    }
+    return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+  };
+  m._En754 = function (a, p, v) {
+
+    var s, e, m, i, d, c, mLen, eLen, eBias, eMax;
+    mLen = el.mLen, eLen = el.len * 8 - el.mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1;
+
+    s = v < 0 ? 1 : 0;
+    v = Math.abs(v);
+    if (isNaN(v) ||  (v  ==  Infinity)) {
+
+      m = isNaN(v) ? 1 : 0;
+      e = eMax;
+    }
+    else {
+      e = Math.floor(Math.log(v) / Math.LN2);     // Calculate log2 of the value
+      if (v * (c = Math.pow(2, -e)) < 1) { e--; c *= 2; }   // Math.log() isn't 100% reliable
+
+      // Round by adding 1 / 2 the significand's LSD
+      if (e + eBias >= 1) {
+        // Normalized:  mLen significand digits
+        v += el.rt / c;
+      }
+      else {
+        // Denormalized:  <= mLen significand digits
+        v += el.rt * Math.pow(2, 1 - eBias);
+      }
+      if (v * c >= 2) {
+        // Rounding can increment the exponent
+        e++; c /= 2;
+      }
+
+      if (e + eBias >= eMax) {
+        // Overflow
+        m = 0;
+        e = eMax;
+      }
+      else if (e + eBias >= 1) {
+
+        // Normalized - term order matters, as Math.pow(2, 52 - e) and v * Math.pow(2, 52) can overflow
+        m = (v * c - 1) * Math.pow(2, mLen);
+        e = e + eBias;
+      }
+      else {
+
+        // Denormalized - also catches the '0' case, somewhat by chance
+        m = v * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+        e = 0;
+      }
+    }
+
+    for (i = bBE ? (el.len - 1) : 0, d = bBE ? -1 : 1; mLen >= 8; a[p + i] = m & 0xff, i += d, m /= 256, mLen -= 8) { }
+    for (e = (e << mLen) | m, eLen += mLen; eLen > 0; a[p + i] = e & 0xff, i += d, e /= 256, eLen -= 8) { }
+    a[p + i - d] |= s * 128;
+  };
+
+  // Convert int64 to array with 3 elements: [lowBits, highBits, unsignedFlag]
+  // '>>>' trick to convert signed 32bit int to unsigned int (because << always results in a signed 32bit int)
+  m._DeInt64 = function (a, p) {
+    var start = bBE ? 0 : 7;
+    var nsb = bBE ? 1 : -1;
+    var stop = start + nsb * 8;
+    var rv = [0, 0, !el.bSigned];
+    var i, f, rvi;
+    for (i = start, rvi = 1, f = 0;
+      i != stop;
+      rv[rvi] = (((rv[rvi] << 8) >>> 0) + a[p + i]), i += nsb, f++, rvi = (f < 4 ? 1 : 0)) {}
+
+    return rv[0] + rv[1]*4294967296;
+    // return rv;
+  };
+
+  m._EnInt64 = function (a, p, v) {
+    if (!Array.isArray(v)) {
+      // it's Number, so lets split it to array
+      v = [
+        v % 4294967296,
+        Math.floor(v / 4294967296),
+        1];
+    }
+
+    var start = bBE ? 0 : 7;
+    var nsb = bBE ? 1 : -1;
+    var stop = start + nsb * 8;
+    var i, f, rvi, s;
+    for (i = start, rvi = 1, f = 0, s = 24;
+      i != stop;
+      a[p + i] = v[rvi] >> s & 0xff, i += nsb, f++, rvi = (f < 4 ? 1 : 0), s = 24 - (8 * (f % 4))) { }
+  };
+
+  // Class data
+  m._sPattern = '(\\d+)?([AxcbBhHsfdiIlLqQ])';
+  m._lenLut = {'A': 1, 'x': 1, 'c': 1, 'b': 1, 'B': 1, 'h': 2, 'H': 2, 's': 1,
+    'f': 4, 'd': 8, 'i': 4, 'I': 4, 'l': 4, 'L': 4, 'q': 8, 'Q': 8
+  };
+  m._elLut  = {'A': {en: m._EnArray, de: m._DeArray},
+        's': {en: m._EnString, de: m._DeString},
+        'c': {en: m._EnChar, de: m._DeChar},
+        'b': {en: m._EnInt, de: m._DeInt, len: 1, bSigned: true, min: -Math.pow(2, 7), max: Math.pow(2, 7) - 1},
+        'B': {en: m._EnInt, de: m._DeInt, len: 1, bSigned: false, min: 0, max: Math.pow(2, 8) - 1},
+        'h': {en: m._EnInt, de: m._DeInt, len: 2, bSigned: true, min: -Math.pow(2, 15), max: Math.pow(2, 15) - 1},
+        'H': {en: m._EnInt, de: m._DeInt, len: 2, bSigned: false, min: 0, max: Math.pow(2, 16) - 1},
+        'i': {en: m._EnInt, de: m._DeInt, len: 4, bSigned: true, min: -Math.pow(2, 31), max: Math.pow(2, 31) - 1},
+        'I': {en: m._EnInt, de: m._DeInt, len: 4, bSigned: false, min: 0, max: Math.pow(2, 32) - 1},
+        'l': {en: m._EnInt, de: m._DeInt, len: 4, bSigned: true, min: -Math.pow(2, 31), max: Math.pow(2, 31) - 1},
+        'L': {en: m._EnInt, de: m._DeInt, len: 4, bSigned: false, min: 0, max: Math.pow(2, 32) - 1},
+        'f': {en: m._En754, de: m._De754, len: 4, mLen: 23, rt: Math.pow(2, -24) - Math.pow(2, -77)},
+        'd': {en: m._En754, de: m._De754, len: 8, mLen: 52, rt: 0},
+        'q': {en: m._EnInt64, de: m._DeInt64, bSigned: true},
+        'Q': {en: m._EnInt64, de: m._DeInt64, bSigned: false}};
+
+  // Unpack a series of n elements of size s from array a at offset p with fxn
+  m._UnpackSeries = function (n, s, a, p) {
+    for (var fxn = el.de, rv = [], i = 0; i < n; rv.push(fxn(a, p + i * s)), i++) { }
+    return rv;
+  };
+
+  // Pack a series of n elements of size s from array v at offset i to array a at offset p with fxn
+  m._PackSeries = function (n, s, a, p, v, i) {
+    for (var fxn = el.en, o = 0; o < n; fxn(a, p + o * s, v[i + o]), o++) { }
+  };
+
+  // Unpack the octet array a, beginning at offset p, according to the fmt string
+  m.UnpackTo = function (fmt, a, p, allowLessData = false) {
+    // Set the private bBE flag based on the format string - assume big-endianness
+    bBE = (fmt.charAt(0) != '<');
+
+    p = p ? p : 0;
+    var re = new RegExp(this._sPattern, 'g');
+    var m, n, s;
+    var rv = [];
+    while (m = re.exec(fmt)) {
+      n = ((m[1]  == undefined) || (m[1] == '')) ? 1 : parseInt(m[1]);
+      s = this._lenLut[m[2]];
+      if ((p + n * s) > a.length) {
+        if (allowLessData) {
+          // We stop here and return what we have already,
+          // or an empty array if this happens in the first iteration.
+          break;
+        } else {
+          return undefined;
+        }
+      }
+      switch (m[2]) {
+        case 'A': case 's':
+          rv.push(this._elLut[m[2]].de(a, p, n));
+          break;
+        case 'c': case 'b': case 'B': case 'h': case 'H':
+        case 'i': case 'I': case 'l': case 'L': case 'f': case 'd': case 'q': case 'Q':
+          el = this._elLut[m[2]];
+          if (n > 1) {
+            // Field is array, unpack into separate array and push as such
+            var arr = [];
+            arr.push(this._UnpackSeries(n, s, a, p));
+            rv.push(arr);
+          } else {
+            rv.push(this._UnpackSeries(n, s, a, p));
+          }
+          break;
+      }
+      p += n * s;
+    }
+    return Array.prototype.concat.apply([], rv);
+  };
+
+  // Pack the supplied values into the octet array a, beginning at offset p, according to the fmt string
+  m.PackTo = function (fmt, a, p, values, allowLessData) {
+    // Set the private bBE flag based on the format string - assume big-endianness
+    bBE = (fmt.charAt(0) != '<');
+
+    var re = new RegExp(this._sPattern, 'g');
+    var m, n, s, j;
+    var i = 0;
+    while (m = re.exec(fmt)) {
+      n = ((m[1] == undefined) || (m[1] == '')) ? 1 : parseInt(m[1]);
+      s = this._lenLut[m[2]];
+      if ((p + n * s) > a.length) {
+        // this should not happen unless CalcLength() is broken
+        return false;
+      }
+      switch (m[2]) {
+        case 'A': case 's':
+          if ((i + 1) > values.length) { return allowLessData ? a.slice(0, p) : false; }
+          this._elLut[m[2]].en(a, p, n, values[i]);
+          i += 1;
+          break;
+        case 'c': case 'b': case 'B': case 'h': case 'H':
+        case 'i': case 'I': case 'l': case 'L': case 'f': case 'd': case 'q': case 'Q':
+          el = this._elLut[m[2]];
+          if (n > 1 && Array.isArray(values[i])) {
+            // Value series is array, iterate through that, only increment by 1
+            if ((i + 1) > values.length) { return allowLessData ? a.slice(0, p) : false; }
+            this._PackSeries(n, s, a, p, values[i], 0);
+            i += 1;
+          } else {
+            if ((i + n) > values.length) { return allowLessData ? a.slice(0, p) : false; }
+            this._PackSeries(n, s, a, p, values, i);
+            i += n;
+          }
+          break;
+        case 'x':
+          for (j = 0; j < n; j++) { a[p + j] = 0; }
+          break;
+      }
+      p += n * s;
+    }
+    return a;
+  };
+
+  // Pack the supplied values into a new octet array, according to the fmt string
+  m.Pack = function (fmt, values, allowLessData = false) {
+    return this.PackTo(fmt, new Array(this.CalcLength(fmt)), 0, values, allowLessData);
+  };
+
+  m.Unpack = function (fmt, values, allowLessData = false) {
+    return this.UnpackTo(fmt, values, 0, allowLessData);
+  };
+
+  // Determine the number of bytes represented by the format string
+  m.CalcLength = function (fmt) {
+    var re = new RegExp(this._sPattern, 'g');
+    var sum = 0;
+    var m;
+    while (m = re.exec(fmt)) {
+      sum += (((m[1]  ==  undefined) ||  (m[1]  ==  '')) ? 1 : parseInt(m[1])) * this._lenLut[m[2]];
+    }
+    return sum;
+  };
+}
+
+export default new JSPack();

package/src/node/Readable.ts

@@ -0,0 +1,61 @@
+import fs from 'fs/promises';
+import type { FileHandle } from 'fs/promises';
+import type { IReadable } from '../types.js';
+
+export class Readable implements IReadable {
+	private _filename: string | undefined;
+	private _prepared = false;
+	private _size = 0;
+	private _fp: FileHandle | null = null;
+
+	constructor(params: { filename?: string } = {}) {
+		this._filename = params.filename;
+	}
+
+	isPrepared(): boolean {
+		return this._prepared;
+	}
+
+	async prepare(): Promise<void> {
+		if (this._prepared) {
+			return;
+		}
+
+		if (this._filename) {
+			this._fp = await fs.open(this._filename, 'r');
+			const stats = await this._fp.stat();
+			this._size = stats.size;
+		}
+
+		this._prepared = true;
+	}
+
+	async close(): Promise<void> {
+		if (this._fp) {
+			try {
+				await this._fp.close();
+			} catch {
+				// file may already be closed
+			}
+		}
+		this._fp = null;
+		this._prepared = false;
+	}
+
+	async getSlice(offset: number, length: number): Promise<Uint8Array> {
+		if (!this._prepared) {
+			await this.prepare();
+		}
+
+		const ret = new Uint8Array(length);
+		await this._fp!.read(ret, 0, length, offset);
+		return ret;
+	}
+
+	async size(): Promise<number> {
+		if (!this._prepared) {
+			await this.prepare();
+		}
+		return this._size;
+	}
+}

package/src/node/Writable.ts

@@ -0,0 +1,85 @@
+import fs from 'fs/promises';
+import { tmpFileSync } from '../utils.js';
+import type { FileHandle } from 'fs/promises';
+import type { IReadable, IWritable } from '../types.js';
+import { Readable } from './Readable.js';
+
+export class Writable implements IWritable {
+	private _uint8Array: Uint8Array = new Uint8Array([]);
+	private _filename: string | undefined;
+	private _prepared = false;
+	private _bytesWrote = 0;
+	private _fp: FileHandle | null = null;
+
+	constructor(params: { filename?: string } = {}) {
+		if (params.filename) {
+			this._filename = params.filename;
+		}
+	}
+
+	size(): number {
+		if (this._filename) {
+			return this._bytesWrote;
+		}
+		return this._uint8Array.length;
+	}
+
+	async prepare(): Promise<void> {
+		if (this._prepared) {
+			return;
+		}
+
+		if (this._filename) {
+			this._fp = await fs.open(this._filename, 'w');
+		}
+
+		this._prepared = true;
+	}
+
+	async close(): Promise<void> {
+		if (this._fp) {
+			try {
+				await this._fp.close();
+			} catch {
+				// file may already be closed
+			}
+			this._fp = null;
+			this._prepared = false;
+		}
+	}
+
+	async saveToFile(filename: string): Promise<void> {
+		await fs.writeFile(filename, this._uint8Array);
+	}
+
+	async write(append: Uint8Array | number[]): Promise<void> {
+		if (!this._prepared) {
+			await this.prepare();
+		}
+
+		const data = append instanceof Uint8Array ? append : Uint8Array.from(append);
+
+		if (this._fp) {
+			await this._fp.write(data, 0, data.length);
+			this._bytesWrote += data.length;
+		} else {
+			const ret = new Uint8Array(this._uint8Array.length + data.length);
+			ret.set(this._uint8Array, 0);
+			ret.set(data, this._uint8Array.length);
+			this._bytesWrote += data.length;
+			this._uint8Array = ret;
+		}
+	}
+
+	async toReadable(): Promise<IReadable> {
+		if (this._filename) {
+			await this.close();
+			return new Readable({ filename: this._filename });
+		} else {
+			const tmpName = tmpFileSync();
+			await this.saveToFile(tmpName);
+			await this.close();
+			return new Readable({ filename: tmpName });
+		}
+	}
+}

package/src/types.ts

@@ -0,0 +1,44 @@
+export interface IReadable {
+  isPrepared(): boolean;
+  prepare(): Promise<void>;
+  close(): Promise<void>;
+  getSlice(offset: number, length: number): Promise<Uint8Array>;
+  size(): Promise<number>;
+}
+
+export interface IWritable {
+  size(): number;
+  prepare(): Promise<void>;
+  close(): Promise<void>;
+  write(data: Uint8Array | number[]): Promise<void>;
+  saveToFile(filename: string): Promise<void>;
+  toReadable(): Promise<IReadable>;
+}
+
+export interface AtomParams {
+  readable?: IReadable;
+  name: string;
+  start: number;
+  size: number;
+  header_size: number;
+  mother?: Atom | null;
+}
+
+export interface FileRecord {
+  filename: string;
+  size: number;
+  meta?: Record<string, unknown>;
+  isEncrypted?: boolean;
+  offset?: number;
+}
+
+export interface EmbedFileParams {
+  filename?: string;
+  file?: unknown;
+  meta?: Record<string, unknown>;
+  key?: Buffer | null;
+  password?: string | null;
+}
+
+// Forward declaration to avoid circular imports
+import type { Atom } from './Atom.js';

package/src/utils.ts

@@ -0,0 +1,6 @@
+import tmp from 'tmp';
+
+export function tmpFileSync(): string {
+	const tmpobj = tmp.fileSync();
+	return tmpobj.name;
+}