@editframe/assets 0.6.0-beta.9 → 0.7.0-beta.4

package/dist/packages/assets/src/Probe.js

@@ -0,0 +1,207 @@
+import { spawn } from "node:child_process";
+import { createReadStream } from "node:fs";
+import * as z from "zod";
+import debug from "debug";
+import { execPromise } from "../../../lib/util/execPromise.js";
+const log = debug("ef:assets:probe");
+const AudioStreamSchema = z.object({
+  index: z.number(),
+  codec_name: z.string(),
+  codec_long_name: z.string(),
+  codec_type: z.literal("audio"),
+  codec_tag_string: z.string(),
+  codec_tag: z.string(),
+  sample_fmt: z.string(),
+  sample_rate: z.string(),
+  channels: z.number(),
+  channel_layout: z.string(),
+  bits_per_sample: z.number(),
+  initial_padding: z.number().optional(),
+  r_frame_rate: z.string(),
+  avg_frame_rate: z.string(),
+  time_base: z.string(),
+  start_pts: z.number(),
+  start_time: z.coerce.number(),
+  duration_ts: z.number(),
+  duration: z.coerce.number(),
+  bit_rate: z.string(),
+  disposition: z.record(z.unknown())
+});
+const VideoStreamSchema = z.object({
+  index: z.number(),
+  codec_name: z.string(),
+  codec_long_name: z.string(),
+  codec_type: z.literal("video"),
+  codec_tag_string: z.string(),
+  codec_tag: z.string(),
+  width: z.number(),
+  height: z.number(),
+  coded_width: z.number(),
+  coded_height: z.number(),
+  r_frame_rate: z.string(),
+  avg_frame_rate: z.string(),
+  time_base: z.string(),
+  start_pts: z.number().optional(),
+  start_time: z.coerce.number().optional(),
+  duration_ts: z.number().optional(),
+  duration: z.coerce.number().optional(),
+  bit_rate: z.string().optional(),
+  disposition: z.record(z.unknown())
+});
+const ProbeFormatSchema = z.object({
+  filename: z.string(),
+  nb_streams: z.number(),
+  nb_programs: z.number(),
+  format_name: z.string(),
+  format_long_name: z.string(),
+  start_time: z.string().optional(),
+  duration: z.string().optional(),
+  size: z.string(),
+  bit_rate: z.string().optional(),
+  probe_score: z.number()
+});
+const StreamSchema = z.discriminatedUnion("codec_type", [
+  AudioStreamSchema,
+  VideoStreamSchema
+]);
+const ProbeSchema = z.object({
+  streams: z.array(StreamSchema),
+  format: ProbeFormatSchema
+});
+class Probe {
+  constructor(absolutePath, rawData) {
+    this.absolutePath = absolutePath;
+    this.data = ProbeSchema.parse(rawData);
+  }
+  static async probePath(absolutePath) {
+    const probeCommand = `ffprobe -v error -show_format -show_streams -of json ${absolutePath}`;
+    log("Probing", probeCommand);
+    const probeResult = await execPromise(probeCommand);
+    log("Probe result", probeResult.stdout);
+    log("Probe stderr", probeResult.stderr);
+    const json = JSON.parse(probeResult.stdout);
+    return new Probe(absolutePath, json);
+  }
+  get audioStreams() {
+    return this.data.streams.filter(
+      (stream) => stream.codec_type === "audio"
+    );
+  }
+  get videoStreams() {
+    return this.data.streams.filter(
+      (stream) => stream.codec_type === "video"
+    );
+  }
+  get streams() {
+    return this.data.streams;
+  }
+  get format() {
+    return this.data.format;
+  }
+  get mustReencodeAudio() {
+    return this.audioStreams.some((stream) => stream.codec_name !== "aac");
+  }
+  get mustReencodeVideo() {
+    return false;
+  }
+  get mustRemux() {
+    return this.format.format_name !== "mp4";
+  }
+  get hasAudio() {
+    return this.audioStreams.length > 0;
+  }
+  get hasVideo() {
+    return this.videoStreams.length > 0;
+  }
+  get isAudioOnly() {
+    return this.audioStreams.length > 0 && this.videoStreams.length === 0;
+  }
+  get isVideoOnly() {
+    return this.audioStreams.length === 0 && this.videoStreams.length > 0;
+  }
+  get mustProcess() {
+    return this.mustReencodeAudio || this.mustReencodeVideo || this.mustRemux;
+  }
+  get ffmpegAudioOptions() {
+    if (!this.hasAudio) {
+      return [];
+    }
+    if (this.mustReencodeAudio) {
+      return [
+        "-c:a",
+        "aac",
+        "-b:a",
+        "192k"
+      ];
+    }
+    return ["-c:a", "copy"];
+  }
+  get ffmpegVideoOptions() {
+    if (!this.hasVideo) {
+      return [];
+    }
+    if (this.mustReencodeVideo) {
+      return [
+        "-c:v",
+        "h264",
+        // Filter out SEI NAL units that aren't supported by the webcodecs decoder
+        "-bsf:v",
+        "filter_units=remove_types=6",
+        "-pix_fmt",
+        "yuv420p"
+      ];
+    }
+    return [
+      "-c:v",
+      "copy",
+      // Filter out SEI NAL units that aren't supported by the webcodecs decoder
+      "-bsf:v",
+      "filter_units=remove_types=6"
+    ];
+  }
+  createConformingReadstream() {
+    if (!this.mustProcess) {
+      return createReadStream(this.absolutePath);
+    }
+    const ffmpegConformanceArgs = [
+      "-i",
+      this.absolutePath,
+      ...this.ffmpegAudioOptions,
+      ...this.ffmpegVideoOptions,
+      "-f",
+      "mp4",
+      "-movflags",
+      "cmaf+frag_keyframe+empty_moov",
+      "pipe:1"
+    ];
+    log("Running ffmpeg", ffmpegConformanceArgs);
+    const ffmpegConformer = spawn("ffmpeg", ffmpegConformanceArgs, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    ffmpegConformer.stderr.on("data", (data) => {
+      log(data.toString());
+    });
+    const ffmpegFragmentArgs = [
+      "-i",
+      "-",
+      "-c",
+      "copy",
+      "-f",
+      "mp4",
+      "-movflags",
+      "frag_keyframe+empty_moov",
+      "pipe:1"
+    ];
+    log("Running ffmpeg", ffmpegFragmentArgs);
+    const ffmpegFragmenter = spawn("ffmpeg", ffmpegFragmentArgs, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    ffmpegConformer.stdout.pipe(ffmpegFragmenter.stdin);
+    return ffmpegFragmenter.stdout;
+  }
+}
+export {
+  AudioStreamSchema,
+  Probe,
+  VideoStreamSchema
+};

package/dist/packages/assets/src/VideoRenderOptions.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const z = require("zod");
+const VideoRenderOptions = z.z.object({
+  mode: z.z.enum(["canvas", "screenshot"]),
+  strategy: z.z.enum(["v1", "v2"]),
+  showFrameBox: z.z.boolean().optional(),
+  encoderOptions: z.z.object({
+    sequenceNumber: z.z.number(),
+    keyframeIntervalMs: z.z.number(),
+    toMs: z.z.number(),
+    fromMs: z.z.number(),
+    shouldPadStart: z.z.boolean(),
+    shouldPadEnd: z.z.boolean(),
+    alignedFromUs: z.z.number(),
+    alignedToUs: z.z.number(),
+    isInitSegment: z.z.boolean(),
+    noVideo: z.z.boolean().optional(),
+    noAudio: z.z.boolean().optional(),
+    video: z.z.object({
+      width: z.z.number(),
+      height: z.z.number(),
+      framerate: z.z.number(),
+      codec: z.z.string(),
+      bitrate: z.z.number()
+    }),
+    audio: z.z.object({
+      sampleRate: z.z.number(),
+      codec: z.z.string(),
+      numberOfChannels: z.z.number(),
+      bitrate: z.z.number()
+    })
+  }),
+  fetchHost: z.z.string()
+});
+exports.VideoRenderOptions = VideoRenderOptions;

package/dist/packages/assets/src/VideoRenderOptions.d.ts

@@ -0,0 +1,169 @@
+import { z } from 'zod';
+
+export declare const VideoRenderOptions: z.ZodObject<{
+    mode: z.ZodEnum<["canvas", "screenshot"]>;
+    strategy: z.ZodEnum<["v1", "v2"]>;
+    showFrameBox: z.ZodOptional<z.ZodBoolean>;
+    encoderOptions: z.ZodObject<{
+        sequenceNumber: z.ZodNumber;
+        keyframeIntervalMs: z.ZodNumber;
+        toMs: z.ZodNumber;
+        fromMs: z.ZodNumber;
+        shouldPadStart: z.ZodBoolean;
+        shouldPadEnd: z.ZodBoolean;
+        alignedFromUs: z.ZodNumber;
+        alignedToUs: z.ZodNumber;
+        isInitSegment: z.ZodBoolean;
+        noVideo: z.ZodOptional<z.ZodBoolean>;
+        noAudio: z.ZodOptional<z.ZodBoolean>;
+        video: z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            framerate: z.ZodNumber;
+            codec: z.ZodString;
+            bitrate: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            width: number;
+            height: number;
+            framerate: number;
+            codec: string;
+            bitrate: number;
+        }, {
+            width: number;
+            height: number;
+            framerate: number;
+            codec: string;
+            bitrate: number;
+        }>;
+        audio: z.ZodObject<{
+            sampleRate: z.ZodNumber;
+            codec: z.ZodString;
+            numberOfChannels: z.ZodNumber;
+            bitrate: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            codec: string;
+            bitrate: number;
+            sampleRate: number;
+            numberOfChannels: number;
+        }, {
+            codec: string;
+            bitrate: number;
+            sampleRate: number;
+            numberOfChannels: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        audio: {
+            codec: string;
+            bitrate: number;
+            sampleRate: number;
+            numberOfChannels: number;
+        };
+        video: {
+            width: number;
+            height: number;
+            framerate: number;
+            codec: string;
+            bitrate: number;
+        };
+        sequenceNumber: number;
+        keyframeIntervalMs: number;
+        toMs: number;
+        fromMs: number;
+        shouldPadStart: boolean;
+        shouldPadEnd: boolean;
+        alignedFromUs: number;
+        alignedToUs: number;
+        isInitSegment: boolean;
+        noVideo?: boolean | undefined;
+        noAudio?: boolean | undefined;
+    }, {
+        audio: {
+            codec: string;
+            bitrate: number;
+            sampleRate: number;
+            numberOfChannels: number;
+        };
+        video: {
+            width: number;
+            height: number;
+            framerate: number;
+            codec: string;
+            bitrate: number;
+        };
+        sequenceNumber: number;
+        keyframeIntervalMs: number;
+        toMs: number;
+        fromMs: number;
+        shouldPadStart: boolean;
+        shouldPadEnd: boolean;
+        alignedFromUs: number;
+        alignedToUs: number;
+        isInitSegment: boolean;
+        noVideo?: boolean | undefined;
+        noAudio?: boolean | undefined;
+    }>;
+    fetchHost: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    mode: "canvas" | "screenshot";
+    strategy: "v1" | "v2";
+    encoderOptions: {
+        audio: {
+            codec: string;
+            bitrate: number;
+            sampleRate: number;
+            numberOfChannels: number;
+        };
+        video: {
+            width: number;
+            height: number;
+            framerate: number;
+            codec: string;
+            bitrate: number;
+        };
+        sequenceNumber: number;
+        keyframeIntervalMs: number;
+        toMs: number;
+        fromMs: number;
+        shouldPadStart: boolean;
+        shouldPadEnd: boolean;
+        alignedFromUs: number;
+        alignedToUs: number;
+        isInitSegment: boolean;
+        noVideo?: boolean | undefined;
+        noAudio?: boolean | undefined;
+    };
+    fetchHost: string;
+    showFrameBox?: boolean | undefined;
+}, {
+    mode: "canvas" | "screenshot";
+    strategy: "v1" | "v2";
+    encoderOptions: {
+        audio: {
+            codec: string;
+            bitrate: number;
+            sampleRate: number;
+            numberOfChannels: number;
+        };
+        video: {
+            width: number;
+            height: number;
+            framerate: number;
+            codec: string;
+            bitrate: number;
+        };
+        sequenceNumber: number;
+        keyframeIntervalMs: number;
+        toMs: number;
+        fromMs: number;
+        shouldPadStart: boolean;
+        shouldPadEnd: boolean;
+        alignedFromUs: number;
+        alignedToUs: number;
+        isInitSegment: boolean;
+        noVideo?: boolean | undefined;
+        noAudio?: boolean | undefined;
+    };
+    fetchHost: string;
+    showFrameBox?: boolean | undefined;
+}>;
+export type VideoRenderOptions = z.infer<typeof VideoRenderOptions>;

package/dist/packages/assets/src/VideoRenderOptions.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+const VideoRenderOptions = z.object({
+  mode: z.enum(["canvas", "screenshot"]),
+  strategy: z.enum(["v1", "v2"]),
+  showFrameBox: z.boolean().optional(),
+  encoderOptions: z.object({
+    sequenceNumber: z.number(),
+    keyframeIntervalMs: z.number(),
+    toMs: z.number(),
+    fromMs: z.number(),
+    shouldPadStart: z.boolean(),
+    shouldPadEnd: z.boolean(),
+    alignedFromUs: z.number(),
+    alignedToUs: z.number(),
+    isInitSegment: z.boolean(),
+    noVideo: z.boolean().optional(),
+    noAudio: z.boolean().optional(),
+    video: z.object({
+      width: z.number(),
+      height: z.number(),
+      framerate: z.number(),
+      codec: z.string(),
+      bitrate: z.number()
+    }),
+    audio: z.object({
+      sampleRate: z.number(),
+      codec: z.string(),
+      numberOfChannels: z.number(),
+      bitrate: z.number()
+    })
+  }),
+  fetchHost: z.string()
+});
+export {
+  VideoRenderOptions
+};

package/dist/packages/assets/src/idempotentTask.cjs

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const node_fs = require("node:fs");
+const path = require("node:path");
+const md5 = require("./md5.cjs");
+const debug = require("debug");
+const promises = require("node:fs/promises");
+const node_stream = require("node:stream");
+const idempotentTask = ({
+  label,
+  filename,
+  runner
+}) => {
+  const tasks = {};
+  return async (rootDir, absolutePath, ...args) => {
+    const log = debug(`ef:${label}`);
+    const md5$1 = await md5.md5FilePath(absolutePath);
+    const cacheDir = path.join(rootDir, ".cache", md5$1);
+    log(`Cache dir: ${cacheDir}`);
+    await promises.mkdir(cacheDir, { recursive: true });
+    const cachePath = path.join(cacheDir, filename(absolutePath, ...args));
+    const key = cachePath;
+    if (node_fs.existsSync(cachePath)) {
+      log(`Returning cached ef:${label} task for ${key}`);
+      return { cachePath, md5Sum: md5$1 };
+    }
+    const maybeTask = tasks[key];
+    if (maybeTask) {
+      log(`Returning existing ef:${label} task for ${key}`);
+      await maybeTask;
+      return { cachePath, md5Sum: md5$1 };
+    }
+    log(`Creating new ef:${label} task for ${key}`);
+    const task = runner(absolutePath, ...args);
+    tasks[key] = task;
+    log(`Awaiting task for ${key}`);
+    const result = await task;
+    if (result instanceof node_stream.Readable) {
+      log(`Piping task for ${key} to cache`);
+      const writeStream = node_fs.createWriteStream(cachePath);
+      result.pipe(writeStream);
+      await new Promise((resolve, reject) => {
+        result.on("error", reject);
+        writeStream.on("error", reject);
+        writeStream.on("finish", resolve);
+      });
+      return { cachePath, md5Sum: md5$1 };
+    }
+    log(`Writing to ${cachePath}`);
+    await promises.writeFile(cachePath, result);
+    return {
+      md5Sum: md5$1,
+      cachePath
+    };
+  };
+};
+exports.idempotentTask = idempotentTask;

package/dist/packages/assets/src/idempotentTask.d.ts

@@ -0,0 +1,13 @@
+import { Readable } from 'node:stream';
+
+interface TaskOptions<T extends unknown[]> {
+    label: string;
+    filename: (absolutePath: string, ...args: T) => string;
+    runner: (absolutePath: string, ...args: T) => Promise<string | Readable>;
+}
+export interface TaskResult {
+    md5Sum: string;
+    cachePath: string;
+}
+export declare const idempotentTask: <T extends unknown[]>({ label, filename, runner, }: TaskOptions<T>) => (rootDir: string, absolutePath: string, ...args: T) => Promise<TaskResult>;
+export {};

package/dist/packages/assets/src/idempotentTask.js

@@ -0,0 +1,57 @@
+import { existsSync, createWriteStream } from "node:fs";
+import path from "node:path";
+import { md5FilePath } from "./md5.js";
+import debug from "debug";
+import { mkdir, writeFile } from "node:fs/promises";
+import { Readable } from "node:stream";
+const idempotentTask = ({
+  label,
+  filename,
+  runner
+}) => {
+  const tasks = {};
+  return async (rootDir, absolutePath, ...args) => {
+    const log = debug(`ef:${label}`);
+    const md5 = await md5FilePath(absolutePath);
+    const cacheDir = path.join(rootDir, ".cache", md5);
+    log(`Cache dir: ${cacheDir}`);
+    await mkdir(cacheDir, { recursive: true });
+    const cachePath = path.join(cacheDir, filename(absolutePath, ...args));
+    const key = cachePath;
+    if (existsSync(cachePath)) {
+      log(`Returning cached ef:${label} task for ${key}`);
+      return { cachePath, md5Sum: md5 };
+    }
+    const maybeTask = tasks[key];
+    if (maybeTask) {
+      log(`Returning existing ef:${label} task for ${key}`);
+      await maybeTask;
+      return { cachePath, md5Sum: md5 };
+    }
+    log(`Creating new ef:${label} task for ${key}`);
+    const task = runner(absolutePath, ...args);
+    tasks[key] = task;
+    log(`Awaiting task for ${key}`);
+    const result = await task;
+    if (result instanceof Readable) {
+      log(`Piping task for ${key} to cache`);
+      const writeStream = createWriteStream(cachePath);
+      result.pipe(writeStream);
+      await new Promise((resolve, reject) => {
+        result.on("error", reject);
+        writeStream.on("error", reject);
+        writeStream.on("finish", resolve);
+      });
+      return { cachePath, md5Sum: md5 };
+    }
+    log(`Writing to ${cachePath}`);
+    await writeFile(cachePath, result);
+    return {
+      md5Sum: md5,
+      cachePath
+    };
+  };
+};
+export {
+  idempotentTask
+};

package/dist/packages/assets/src/index.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Probe = require("./Probe.cjs");
+const md5 = require("./md5.cjs");
+const generateTrackFragmentIndex = require("./tasks/generateTrackFragmentIndex.cjs");
+const generateTrack = require("./tasks/generateTrack.cjs");
+const findOrCreateCaptions = require("./tasks/findOrCreateCaptions.cjs");
+const cacheImage = require("./tasks/cacheImage.cjs");
+const VideoRenderOptions = require("./VideoRenderOptions.cjs");
+exports.AudioStreamSchema = Probe.AudioStreamSchema;
+exports.Probe = Probe.Probe;
+exports.VideoStreamSchema = Probe.VideoStreamSchema;
+exports.md5Directory = md5.md5Directory;
+exports.md5FilePath = md5.md5FilePath;
+exports.md5ReadStream = md5.md5ReadStream;
+exports.generateTrackFragmentIndex = generateTrackFragmentIndex.generateTrackFragmentIndex;
+exports.generateTrack = generateTrack.generateTrack;
+exports.findOrCreateCaptions = findOrCreateCaptions.findOrCreateCaptions;
+exports.cacheImage = cacheImage.cacheImage;
+exports.VideoRenderOptions = VideoRenderOptions.VideoRenderOptions;

package/dist/packages/assets/src/index.d.ts

@@ -0,0 +1,9 @@
+export { AudioStreamSchema, VideoStreamSchema, Probe } from './Probe';
+export type { StreamSchema, TrackSegment, TrackFragmentIndex } from './Probe';
+export { md5FilePath, md5Directory, md5ReadStream } from './md5';
+export { generateTrackFragmentIndex } from './tasks/generateTrackFragmentIndex';
+export { generateTrack } from './tasks/generateTrack';
+export { findOrCreateCaptions } from './tasks/findOrCreateCaptions';
+export { cacheImage } from './tasks/cacheImage';
+export type { TaskResult } from './idempotentTask';
+export { VideoRenderOptions } from './VideoRenderOptions';

package/dist/packages/assets/src/index.js

@@ -0,0 +1,20 @@
+import { AudioStreamSchema, Probe, VideoStreamSchema } from "./Probe.js";
+import { md5Directory, md5FilePath, md5ReadStream } from "./md5.js";
+import { generateTrackFragmentIndex } from "./tasks/generateTrackFragmentIndex.js";
+import { generateTrack } from "./tasks/generateTrack.js";
+import { findOrCreateCaptions } from "./tasks/findOrCreateCaptions.js";
+import { cacheImage } from "./tasks/cacheImage.js";
+import { VideoRenderOptions } from "./VideoRenderOptions.js";
+export {
+  AudioStreamSchema,
+  Probe,
+  VideoRenderOptions,
+  VideoStreamSchema,
+  cacheImage,
+  findOrCreateCaptions,
+  generateTrack,
+  generateTrackFragmentIndex,
+  md5Directory,
+  md5FilePath,
+  md5ReadStream
+};

package/dist/packages/assets/src/md5.cjs

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const node_fs = require("node:fs");
+const promises = require("node:fs/promises");
+const path = require("node:path");
+const crypto = require("node:crypto");
+const ora = require("ora");
+async function md5Directory(directory, spinner) {
+  const shouldEndSpinner = !spinner;
+  spinner ||= ora("⚡️ Calculating MD5").start();
+  spinner.suffixText = directory;
+  const files = await promises.readdir(directory, { withFileTypes: true });
+  const hashes = await Promise.all(
+    files.map(async (file) => {
+      const filePath = path.join(directory, file.name);
+      if (file.isDirectory()) {
+        return md5Directory(filePath, spinner);
+      }
+      spinner.suffixText = filePath;
+      return md5FilePath(filePath);
+    })
+  );
+  const hash = crypto.createHash("md5");
+  for (const fileHash of hashes) {
+    hash.update(fileHash);
+  }
+  if (shouldEndSpinner) {
+    spinner.succeed("MD5 calculated");
+    spinner.suffixText = directory;
+  }
+  return addDashesToUUID(hash.digest("hex"));
+}
+async function md5FilePath(filePath) {
+  const readStream = node_fs.createReadStream(filePath);
+  return md5ReadStream(readStream);
+}
+function md5ReadStream(readStream) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("md5");
+    readStream.on("data", (data) => {
+      hash.update(data);
+    });
+    readStream.on("error", reject);
+    readStream.on("end", () => {
+      resolve(addDashesToUUID(hash.digest("hex")));
+    });
+  });
+}
+function addDashesToUUID(uuidWithoutDashes) {
+  if (uuidWithoutDashes.length !== 32) {
+    throw new Error("Invalid UUID without dashes. Expected 32 characters.");
+  }
+  return (
+    // biome-ignore lint/style/useTemplate: using a template makes a long line
+    uuidWithoutDashes.slice(0, 8) + "-" + uuidWithoutDashes.slice(8, 12) + "-" + uuidWithoutDashes.slice(12, 16) + "-" + uuidWithoutDashes.slice(16, 20) + "-" + uuidWithoutDashes.slice(20, 32)
+  );
+}
+exports.md5Directory = md5Directory;
+exports.md5FilePath = md5FilePath;
+exports.md5ReadStream = md5ReadStream;