agdi 3.3.6 → 3.3.8

package/dist/DsdiffParser-OJREDMBI.js

@@ -0,0 +1,188 @@
+import {
+  ID3v2Parser
+} from "./chunk-65JVFJ3X.js";
+import "./chunk-2B4QMSZW.js";
+import {
+  FourCcToken
+} from "./chunk-YIHDW7JC.js";
+import {
+  fromBuffer
+} from "./chunk-HNLU36CC.js";
+import "./chunk-LREP5CZP.js";
+import "./chunk-GD35BJSH.js";
+import {
+  BasicParser,
+  INT64_BE,
+  StringType,
+  UINT16_BE,
+  UINT32_BE,
+  UINT32_LE,
+  UINT8,
+  Uint8ArrayType,
+  makeUnexpectedFileContentError,
+  require_src
+} from "./chunk-VGOIHW7D.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/dsdiff/DsdiffParser.js
+var import_debug = __toESM(require_src(), 1);
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/dsdiff/DsdiffToken.js
+var ChunkHeader64 = {
+  len: 12,
+  get: (buf, off) => {
+    return {
+      // Group-ID
+      chunkID: FourCcToken.get(buf, off),
+      // Size
+      chunkSize: INT64_BE.get(buf, off + 4)
+    };
+  }
+};
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/dsdiff/DsdiffParser.js
+var debug = (0, import_debug.default)("music-metadata:parser:aiff");
+var DsdiffContentParseError = class extends makeUnexpectedFileContentError("DSDIFF") {
+};
+var DsdiffParser = class extends BasicParser {
+  async parse() {
+    const header = await this.tokenizer.readToken(ChunkHeader64);
+    if (header.chunkID !== "FRM8")
+      throw new DsdiffContentParseError("Unexpected chunk-ID");
+    this.metadata.setAudioOnly();
+    const type = (await this.tokenizer.readToken(FourCcToken)).trim();
+    switch (type) {
+      case "DSD":
+        this.metadata.setFormat("container", `DSDIFF/${type}`);
+        this.metadata.setFormat("lossless", true);
+        return this.readFmt8Chunks(header.chunkSize - BigInt(FourCcToken.len));
+      default:
+        throw new DsdiffContentParseError(`Unsupported DSDIFF type: ${type}`);
+    }
+  }
+  async readFmt8Chunks(remainingSize) {
+    while (remainingSize >= ChunkHeader64.len) {
+      const chunkHeader = await this.tokenizer.readToken(ChunkHeader64);
+      debug(`Chunk id=${chunkHeader.chunkID}`);
+      await this.readData(chunkHeader);
+      remainingSize -= BigInt(ChunkHeader64.len) + chunkHeader.chunkSize;
+    }
+  }
+  async readData(header) {
+    debug(`Reading data of chunk[ID=${header.chunkID}, size=${header.chunkSize}]`);
+    const p0 = this.tokenizer.position;
+    switch (header.chunkID.trim()) {
+      case "FVER": {
+        const version = await this.tokenizer.readToken(UINT32_LE);
+        debug(`DSDIFF version=${version}`);
+        break;
+      }
+      case "PROP": {
+        const propType = await this.tokenizer.readToken(FourCcToken);
+        if (propType !== "SND ")
+          throw new DsdiffContentParseError("Unexpected PROP-chunk ID");
+        await this.handleSoundPropertyChunks(header.chunkSize - BigInt(FourCcToken.len));
+        break;
+      }
+      case "ID3": {
+        const id3_data = await this.tokenizer.readToken(new Uint8ArrayType(Number(header.chunkSize)));
+        const rst = fromBuffer(id3_data);
+        await new ID3v2Parser().parse(this.metadata, rst, this.options);
+        break;
+      }
+      case "DSD":
+        if (this.metadata.format.numberOfChannels) {
+          this.metadata.setFormat("numberOfSamples", Number(header.chunkSize * BigInt(8) / BigInt(this.metadata.format.numberOfChannels)));
+        }
+        if (this.metadata.format.numberOfSamples && this.metadata.format.sampleRate) {
+          this.metadata.setFormat("duration", this.metadata.format.numberOfSamples / this.metadata.format.sampleRate);
+        }
+        break;
+      default:
+        debug(`Ignore chunk[ID=${header.chunkID}, size=${header.chunkSize}]`);
+        break;
+    }
+    const remaining = header.chunkSize - BigInt(this.tokenizer.position - p0);
+    if (remaining > 0) {
+      debug(`After Parsing chunk, remaining ${remaining} bytes`);
+      await this.tokenizer.ignore(Number(remaining));
+    }
+  }
+  async handleSoundPropertyChunks(remainingSize) {
+    debug(`Parsing sound-property-chunks, remainingSize=${remainingSize}`);
+    while (remainingSize > 0) {
+      const sndPropHeader = await this.tokenizer.readToken(ChunkHeader64);
+      debug(`Sound-property-chunk[ID=${sndPropHeader.chunkID}, size=${sndPropHeader.chunkSize}]`);
+      const p0 = this.tokenizer.position;
+      switch (sndPropHeader.chunkID.trim()) {
+        case "FS": {
+          const sampleRate = await this.tokenizer.readToken(UINT32_BE);
+          this.metadata.setFormat("sampleRate", sampleRate);
+          break;
+        }
+        case "CHNL": {
+          const numChannels = await this.tokenizer.readToken(UINT16_BE);
+          this.metadata.setFormat("numberOfChannels", numChannels);
+          await this.handleChannelChunks(sndPropHeader.chunkSize - BigInt(UINT16_BE.len));
+          break;
+        }
+        case "CMPR": {
+          const compressionIdCode = (await this.tokenizer.readToken(FourCcToken)).trim();
+          const count = await this.tokenizer.readToken(UINT8);
+          const compressionName = await this.tokenizer.readToken(new StringType(count, "ascii"));
+          if (compressionIdCode === "DSD") {
+            this.metadata.setFormat("lossless", true);
+            this.metadata.setFormat("bitsPerSample", 1);
+          }
+          this.metadata.setFormat("codec", `${compressionIdCode} (${compressionName})`);
+          break;
+        }
+        case "ABSS": {
+          const hours = await this.tokenizer.readToken(UINT16_BE);
+          const minutes = await this.tokenizer.readToken(UINT8);
+          const seconds = await this.tokenizer.readToken(UINT8);
+          const samples = await this.tokenizer.readToken(UINT32_BE);
+          debug(`ABSS ${hours}:${minutes}:${seconds}.${samples}`);
+          break;
+        }
+        case "LSCO": {
+          const lsConfig = await this.tokenizer.readToken(UINT16_BE);
+          debug(`LSCO lsConfig=${lsConfig}`);
+          break;
+        }
+        default:
+          debug(`Unknown sound-property-chunk[ID=${sndPropHeader.chunkID}, size=${sndPropHeader.chunkSize}]`);
+          await this.tokenizer.ignore(Number(sndPropHeader.chunkSize));
+      }
+      const remaining = sndPropHeader.chunkSize - BigInt(this.tokenizer.position - p0);
+      if (remaining > 0) {
+        debug(`After Parsing sound-property-chunk ${sndPropHeader.chunkSize}, remaining ${remaining} bytes`);
+        await this.tokenizer.ignore(Number(remaining));
+      }
+      remainingSize -= BigInt(ChunkHeader64.len) + sndPropHeader.chunkSize;
+      debug(`Parsing sound-property-chunks, remainingSize=${remainingSize}`);
+    }
+    if (this.metadata.format.lossless && this.metadata.format.sampleRate && this.metadata.format.numberOfChannels && this.metadata.format.bitsPerSample) {
+      const bitrate = this.metadata.format.sampleRate * this.metadata.format.numberOfChannels * this.metadata.format.bitsPerSample;
+      this.metadata.setFormat("bitrate", bitrate);
+    }
+  }
+  async handleChannelChunks(remainingSize) {
+    debug(`Parsing channel-chunks, remainingSize=${remainingSize}`);
+    const channels = [];
+    while (remainingSize >= FourCcToken.len) {
+      const channelId = await this.tokenizer.readToken(FourCcToken);
+      debug(`Channel[ID=${channelId}]`);
+      channels.push(channelId);
+      remainingSize -= BigInt(FourCcToken.len);
+    }
+    debug(`Channels: ${channels.join(", ")}`);
+    return channels;
+  }
+};
+export {
+  DsdiffContentParseError,
+  DsdiffParser
+};

package/dist/DsfParser-2YL4ARJ7.js

@@ -0,0 +1,110 @@
+import {
+  AbstractID3Parser
+} from "./chunk-3JKZUGPJ.js";
+import {
+  ID3v2Parser
+} from "./chunk-65JVFJ3X.js";
+import "./chunk-2B4QMSZW.js";
+import {
+  FourCcToken
+} from "./chunk-YIHDW7JC.js";
+import "./chunk-HNLU36CC.js";
+import "./chunk-LREP5CZP.js";
+import "./chunk-GD35BJSH.js";
+import {
+  INT32_LE,
+  INT64_LE,
+  UINT64_LE,
+  makeUnexpectedFileContentError,
+  require_src
+} from "./chunk-VGOIHW7D.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/dsf/DsfParser.js
+var import_debug = __toESM(require_src(), 1);
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/dsf/DsfChunk.js
+var ChunkHeader = {
+  len: 12,
+  get: (buf, off) => {
+    return { id: FourCcToken.get(buf, off), size: UINT64_LE.get(buf, off + 4) };
+  }
+};
+var DsdChunk = {
+  len: 16,
+  get: (buf, off) => {
+    return {
+      fileSize: INT64_LE.get(buf, off),
+      metadataPointer: INT64_LE.get(buf, off + 8)
+    };
+  }
+};
+var FormatChunk = {
+  len: 40,
+  get: (buf, off) => {
+    return {
+      formatVersion: INT32_LE.get(buf, off),
+      formatID: INT32_LE.get(buf, off + 4),
+      channelType: INT32_LE.get(buf, off + 8),
+      channelNum: INT32_LE.get(buf, off + 12),
+      samplingFrequency: INT32_LE.get(buf, off + 16),
+      bitsPerSample: INT32_LE.get(buf, off + 20),
+      sampleCount: INT64_LE.get(buf, off + 24),
+      blockSizePerChannel: INT32_LE.get(buf, off + 32)
+    };
+  }
+};
+
+// ../../node_modules/.pnpm/music-metadata@11.12.0/node_modules/music-metadata/lib/dsf/DsfParser.js
+var debug = (0, import_debug.default)("music-metadata:parser:DSF");
+var DsdContentParseError = class extends makeUnexpectedFileContentError("DSD") {
+};
+var DsfParser = class extends AbstractID3Parser {
+  async postId3v2Parse() {
+    const p0 = this.tokenizer.position;
+    const chunkHeader = await this.tokenizer.readToken(ChunkHeader);
+    if (chunkHeader.id !== "DSD ")
+      throw new DsdContentParseError("Invalid chunk signature");
+    this.metadata.setFormat("container", "DSF");
+    this.metadata.setFormat("lossless", true);
+    this.metadata.setAudioOnly();
+    const dsdChunk = await this.tokenizer.readToken(DsdChunk);
+    if (dsdChunk.metadataPointer === BigInt(0)) {
+      debug("No ID3v2 tag present");
+    } else {
+      debug(`expect ID3v2 at offset=${dsdChunk.metadataPointer}`);
+      await this.parseChunks(dsdChunk.fileSize - chunkHeader.size);
+      await this.tokenizer.ignore(Number(dsdChunk.metadataPointer) - this.tokenizer.position - p0);
+      return new ID3v2Parser().parse(this.metadata, this.tokenizer, this.options);
+    }
+  }
+  async parseChunks(bytesRemaining) {
+    while (bytesRemaining >= ChunkHeader.len) {
+      const chunkHeader = await this.tokenizer.readToken(ChunkHeader);
+      debug(`Parsing chunk name=${chunkHeader.id} size=${chunkHeader.size}`);
+      switch (chunkHeader.id) {
+        case "fmt ": {
+          const formatChunk = await this.tokenizer.readToken(FormatChunk);
+          this.metadata.setFormat("numberOfChannels", formatChunk.channelNum);
+          this.metadata.setFormat("sampleRate", formatChunk.samplingFrequency);
+          this.metadata.setFormat("bitsPerSample", formatChunk.bitsPerSample);
+          this.metadata.setFormat("numberOfSamples", formatChunk.sampleCount);
+          this.metadata.setFormat("duration", Number(formatChunk.sampleCount) / formatChunk.samplingFrequency);
+          const bitrate = formatChunk.bitsPerSample * formatChunk.samplingFrequency * formatChunk.channelNum;
+          this.metadata.setFormat("bitrate", bitrate);
+          return;
+        }
+        default:
+          this.tokenizer.ignore(Number(chunkHeader.size) - ChunkHeader.len);
+          break;
+      }
+      bytesRemaining -= chunkHeader.size;
+    }
+  }
+};
+export {
+  DsdContentParseError,
+  DsfParser
+};

package/dist/FlacParser-IVV4RYF6.js

@@ -0,0 +1,15 @@
+import {
+  FlacParser
+} from "./chunk-AGSFUVRG.js";
+import "./chunk-3JKZUGPJ.js";
+import "./chunk-65JVFJ3X.js";
+import "./chunk-2B4QMSZW.js";
+import "./chunk-YIHDW7JC.js";
+import "./chunk-HNLU36CC.js";
+import "./chunk-LREP5CZP.js";
+import "./chunk-GD35BJSH.js";
+import "./chunk-VGOIHW7D.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  FlacParser
+};