@probityrules/jsmediatags 4.0.0

package/build/MP4TagReader.js

@@ -0,0 +1,291 @@
+'use strict';
+const MediaTagReader = require('./MediaTagReader');
+const MediaFileReader = require('./MediaFileReader');
+class MP4TagReader extends MediaTagReader {
+    static getTagIdentifierByteRange() {
+        // The tag identifier is located in [4, 8] but since we'll need to reader
+        // the header of the first block anyway, we load it instead to avoid
+        // making two requests.
+        return {
+            offset: 0,
+            length: 16
+        };
+    }
+    static canReadTagFormat(tagIdentifier) {
+        var id = String.fromCharCode.apply(String, tagIdentifier.slice(4, 8));
+        return id === "ftyp";
+    }
+    _loadData(mediaFileReader, callbacks) {
+        // MP4 metadata isn't located in a specific location of the file. Roughly
+        // speaking, it's composed of blocks chained together like a linked list.
+        // These blocks are called atoms (or boxes).
+        // Each atom of the list can have its own child linked list. Atoms in this
+        // situation do not possess any data and are called "container" as they only
+        // contain other atoms.
+        // Other atoms represent a particular set of data, like audio, video or
+        // metadata. In order to find and load all the interesting atoms we need
+        // to traverse the entire linked list of atoms and only load the ones
+        // associated with metadata.
+        // The metadata atoms can be find under the "moov.udta.meta.ilst" hierarchy.
+        var self = this;
+        // Load the header of the first atom
+        mediaFileReader.loadRange([0, 16], {
+            onSuccess: function () {
+                self._loadAtom(mediaFileReader, 0, "", callbacks);
+            },
+            onError: callbacks.onError
+        });
+    }
+    _loadAtom(mediaFileReader, offset, parentAtomFullName, callbacks) {
+        if (offset >= mediaFileReader.getSize()) {
+            callbacks.onSuccess();
+            return;
+        }
+        var self = this;
+        // 8 is the size of the atomSize and atomName fields.
+        // When reading the current block we always read 8 more bytes in order
+        // to also read the header of the next block.
+        var atomSize = mediaFileReader.getLongAt(offset, true);
+        if (atomSize == 0 || isNaN(atomSize)) {
+            callbacks.onSuccess();
+            return;
+        }
+        var atomName = mediaFileReader.getStringAt(offset + 4, 4);
+        // console.log(parentAtomFullName, atomName, atomSize);
+        // Container atoms (no actual data)
+        if (this._isContainerAtom(atomName)) {
+            if (atomName == "meta") {
+                // The "meta" atom breaks convention and is a container with data.
+                offset += 4; // next_item_id (uint32)
+            }
+            var atomFullName = (parentAtomFullName ? parentAtomFullName + "." : "") + atomName;
+            if (atomFullName === "moov.udta.meta.ilst") {
+                mediaFileReader.loadRange([offset, offset + atomSize], callbacks);
+            }
+            else {
+                mediaFileReader.loadRange([offset + 8, offset + 8 + 8], {
+                    onSuccess: function () {
+                        self._loadAtom(mediaFileReader, offset + 8, atomFullName, callbacks);
+                    },
+                    onError: callbacks.onError
+                });
+            }
+        }
+        else {
+            mediaFileReader.loadRange([offset + atomSize, offset + atomSize + 8], {
+                onSuccess: function () {
+                    self._loadAtom(mediaFileReader, offset + atomSize, parentAtomFullName, callbacks);
+                },
+                onError: callbacks.onError
+            });
+        }
+    }
+    _isContainerAtom(atomName) {
+        return ["moov", "udta", "meta", "ilst"].indexOf(atomName) >= 0;
+    }
+    _canReadAtom(atomName) {
+        return atomName !== "----";
+    }
+    _parseData(data, tagsToRead) {
+        const tags = {};
+        tagsToRead = this._expandShortcutTags(tagsToRead);
+        this._readAtom(tags, data, 0, data.getSize(), tagsToRead);
+        for (const name in SHORTCUTS) {
+            if (SHORTCUTS.hasOwnProperty(name)) {
+                const raw = tags[SHORTCUTS[name]];
+                const tag = raw;
+                if (tag) {
+                    if (name === "track") {
+                        const td = tag.data;
+                        tags[name] = td.track;
+                    }
+                    else {
+                        tags[name] = tag.data;
+                    }
+                }
+            }
+        }
+        return {
+            type: "MP4",
+            ftyp: data.getStringAt(8, 4),
+            version: data.getLongAt(12, true),
+            tags: tags,
+        };
+    }
+    _readAtom(tags, data, offset, length, tagsToRead, parentAtomFullName, indent) {
+        indent = indent === undefined ? "" : indent + "  ";
+        var seek = offset;
+        while (seek < offset + length) {
+            var atomSize = data.getLongAt(seek, true);
+            if (atomSize == 0) {
+                return;
+            }
+            var atomName = data.getStringAt(seek + 4, 4);
+            // console.log(seek, parentAtomFullName, atomName, atomSize);
+            if (this._isContainerAtom(atomName)) {
+                if (atomName == "meta") {
+                    seek += 4; // next_item_id (uint32)
+                }
+                var atomFullName = (parentAtomFullName ? parentAtomFullName + "." : "") + atomName;
+                this._readAtom(tags, data, seek + 8, atomSize - 8, tagsToRead, atomFullName, indent);
+                return;
+            }
+            // Value atoms
+            if ((!tagsToRead || tagsToRead.indexOf(atomName) >= 0) &&
+                parentAtomFullName === "moov.udta.meta.ilst" &&
+                this._canReadAtom(atomName)) {
+                tags[atomName] = this._readMetadataAtom(data, seek);
+            }
+            seek += atomSize;
+        }
+    }
+    _readMetadataAtom(data, offset) {
+        // 16: size + name + size + "data" (4 bytes each)
+        // 8: 1 byte atom version & 3 bytes atom flags + 4 bytes NULL space
+        // 8: 4 bytes track + 4 bytes total
+        const METADATA_HEADER = 16;
+        var atomSize = data.getLongAt(offset, true);
+        var atomName = data.getStringAt(offset + 4, 4);
+        var klass = data.getInteger24At(offset + METADATA_HEADER + 1, true);
+        let type = TYPES[String(klass)];
+        let atomData;
+        var bigEndian = true;
+        if (atomName == "trkn") {
+            atomData = {
+                track: data.getShortAt(offset + METADATA_HEADER + 10, bigEndian),
+                total: data.getShortAt(offset + METADATA_HEADER + 14, bigEndian),
+            };
+        }
+        else if (atomName == "disk") {
+            atomData = {
+                disk: data.getShortAt(offset + METADATA_HEADER + 10, bigEndian),
+                total: data.getShortAt(offset + METADATA_HEADER + 14, bigEndian),
+            };
+        }
+        else {
+            var atomHeader = METADATA_HEADER + 4 + 4;
+            var dataStart = offset + atomHeader;
+            var dataLength = atomSize - atomHeader;
+            if (atomName === "covr" && type === "uint8") {
+                type = "jpeg";
+            }
+            switch (type) {
+                case "text":
+                    atomData = data
+                        .getStringWithCharsetAt(dataStart, dataLength, "utf-8")
+                        .toString();
+                    break;
+                case "uint8":
+                    atomData = data.getShortAt(dataStart, false);
+                    break;
+                case "int":
+                case "uint": {
+                    const intReader = type == "int"
+                        ? dataLength == 1
+                            ? data.getSByteAt
+                            : dataLength == 2
+                                ? data.getSShortAt
+                                : dataLength == 4
+                                    ? data.getSLongAt
+                                    : data.getLongAt
+                        : dataLength == 1
+                            ? data.getByteAt
+                            : dataLength == 2
+                                ? data.getShortAt
+                                : data.getLongAt;
+                    atomData = intReader.call(data, dataStart + (dataLength == 8 ? 4 : 0), true);
+                    break;
+                }
+                case "jpeg":
+                case "png":
+                    atomData = {
+                        format: "image/" + type,
+                        data: data.getBytesAt(dataStart, dataLength),
+                    };
+                    break;
+            }
+        }
+        return {
+            id: atomName,
+            size: atomSize,
+            description: ATOM_DESCRIPTIONS[atomName] || "Unknown",
+            data: atomData
+        };
+    }
+    getShortcuts() {
+        return SHORTCUTS;
+    }
+}
+/*
+ * https://developer.apple.com/library/content/documentation/QuickTime/QTFF/Metadata/Metadata.html#//apple_ref/doc/uid/TP40000939-CH1-SW35
+*/
+const TYPES = {
+    "0": "uint8",
+    "1": "text",
+    "13": "jpeg",
+    "14": "png",
+    "21": "int",
+    "22": "uint"
+};
+const ATOM_DESCRIPTIONS = {
+    "©alb": "Album",
+    "©ART": "Artist",
+    "aART": "Album Artist",
+    "©day": "Release Date",
+    "©nam": "Title",
+    "©gen": "Genre",
+    "gnre": "Genre",
+    "trkn": "Track Number",
+    "©wrt": "Composer",
+    "©too": "Encoding Tool",
+    "©enc": "Encoded By",
+    "cprt": "Copyright",
+    "covr": "Cover Art",
+    "©grp": "Grouping",
+    "keyw": "Keywords",
+    "©lyr": "Lyrics",
+    "©cmt": "Comment",
+    "tmpo": "Tempo",
+    "cpil": "Compilation",
+    "disk": "Disc Number",
+    "tvsh": "TV Show Name",
+    "tven": "TV Episode ID",
+    "tvsn": "TV Season",
+    "tves": "TV Episode",
+    "tvnn": "TV Network",
+    "desc": "Description",
+    "ldes": "Long Description",
+    "sonm": "Sort Name",
+    "soar": "Sort Artist",
+    "soaa": "Sort Album",
+    "soco": "Sort Composer",
+    "sosn": "Sort Show",
+    "purd": "Purchase Date",
+    "pcst": "Podcast",
+    "purl": "Podcast URL",
+    "catg": "Category",
+    "hdvd": "HD Video",
+    "stik": "Media Type",
+    "rtng": "Content Rating",
+    "pgap": "Gapless Playback",
+    "apID": "Purchase Account",
+    "sfID": "Country Code",
+    "atID": "Artist ID",
+    "cnID": "Catalog ID",
+    "plID": "Collection ID",
+    "geID": "Genre ID",
+    "xid ": "Vendor Information",
+    "flvr": "Codec Flavor"
+};
+const SHORTCUTS = {
+    "title": "©nam",
+    "artist": "©ART",
+    "album": "©alb",
+    "year": "©day",
+    "comment": "©cmt",
+    "track": "trkn",
+    "genre": "©gen",
+    "picture": "covr",
+    "lyrics": "©lyr"
+};
+module.exports = MP4TagReader;

package/build/MediaFileReader.d.ts

@@ -0,0 +1,46 @@
+import type { DecodedString } from "./DecodedString";
+import type { LoadCallbackType, CharsetType } from "./types";
+declare class MediaFileReader {
+    protected _isInitialized: boolean;
+    protected _size: number;
+    constructor(_path?: unknown);
+    /**
+     * Decides if this media file reader is able to read the given file.
+     */
+    static canReadFile(_file: unknown): boolean;
+    /**
+     * This function needs to be called before any other function.
+     * Loads the necessary initial information from the file.
+     */
+    init(callbacks: LoadCallbackType): void;
+    _init(callbacks: LoadCallbackType): void;
+    /**
+     * @param range The start and end indexes of the range to load.
+     *        Ex: [0, 7] load bytes 0 to 7 inclusive.
+     */
+    loadRange(range: [number, number], callbacks: LoadCallbackType): void;
+    /**
+     * @return The size of the file in bytes.
+     */
+    getSize(): number;
+    getByteAt(offset: number): number;
+    getBytesAt(offset: number, length: number): Array<number>;
+    isBitSetAt(offset: number, bit: number): boolean;
+    getSByteAt(offset: number): number;
+    getShortAt(offset: number, isBigEndian: boolean): number;
+    getSShortAt(offset: number, isBigEndian: boolean): number;
+    getLongAt(offset: number, isBigEndian: boolean): number;
+    getSLongAt(offset: number, isBigEndian: boolean): number;
+    getInteger24At(offset: number, isBigEndian: boolean): number;
+    getStringAt(offset: number, length: number): string;
+    getStringWithCharsetAt(offset: number, length: number, charset?: CharsetType | null): DecodedString;
+    getCharAt(offset: number): string;
+    /**
+     * The ID3v2 tag/frame size is encoded with four bytes where the most
+     * significant bit (bit 7) is set to zero in every byte, making a total of 28
+     * bits. The zeroed bits are ignored, so a 257 bytes long tag is represented
+     * as $00 00 02 01.
+     */
+    getSynchsafeInteger32At(offset: number): number;
+}
+export = MediaFileReader;

package/build/MediaFileReader.js

@@ -0,0 +1,168 @@
+"use strict";
+const StringUtils = require("./StringUtils");
+class MediaFileReader {
+    constructor(_path) {
+        this._isInitialized = false;
+        this._size = 0;
+    }
+    /**
+     * Decides if this media file reader is able to read the given file.
+     */
+    static canReadFile(_file) {
+        throw new Error("Must implement canReadFile function");
+    }
+    /**
+     * This function needs to be called before any other function.
+     * Loads the necessary initial information from the file.
+     */
+    init(callbacks) {
+        const self = this;
+        if (this._isInitialized) {
+            setTimeout(callbacks.onSuccess, 1);
+        }
+        else {
+            this._init({
+                onSuccess: function () {
+                    self._isInitialized = true;
+                    callbacks.onSuccess();
+                },
+                onError: callbacks.onError,
+            });
+        }
+    }
+    _init(callbacks) {
+        throw new Error("Must implement init function");
+    }
+    /**
+     * @param range The start and end indexes of the range to load.
+     *        Ex: [0, 7] load bytes 0 to 7 inclusive.
+     */
+    loadRange(range, callbacks) {
+        throw new Error("Must implement loadRange function");
+    }
+    /**
+     * @return The size of the file in bytes.
+     */
+    getSize() {
+        if (!this._isInitialized) {
+            throw new Error("init() must be called first.");
+        }
+        return this._size;
+    }
+    getByteAt(offset) {
+        throw new Error("Must implement getByteAt function");
+    }
+    getBytesAt(offset, length) {
+        const bytes = new Array(length);
+        for (let i = 0; i < length; i++) {
+            bytes[i] = this.getByteAt(offset + i);
+        }
+        return bytes;
+    }
+    isBitSetAt(offset, bit) {
+        const iByte = this.getByteAt(offset);
+        return (iByte & (1 << bit)) != 0;
+    }
+    getSByteAt(offset) {
+        const iByte = this.getByteAt(offset);
+        if (iByte > 127) {
+            return iByte - 256;
+        }
+        else {
+            return iByte;
+        }
+    }
+    getShortAt(offset, isBigEndian) {
+        let iShort = isBigEndian
+            ? (this.getByteAt(offset) << 8) + this.getByteAt(offset + 1)
+            : (this.getByteAt(offset + 1) << 8) + this.getByteAt(offset);
+        if (iShort < 0) {
+            iShort += 65536;
+        }
+        return iShort;
+    }
+    getSShortAt(offset, isBigEndian) {
+        const iUShort = this.getShortAt(offset, isBigEndian);
+        if (iUShort > 32767) {
+            return iUShort - 65536;
+        }
+        else {
+            return iUShort;
+        }
+    }
+    getLongAt(offset, isBigEndian) {
+        const iByte1 = this.getByteAt(offset), iByte2 = this.getByteAt(offset + 1), iByte3 = this.getByteAt(offset + 2), iByte4 = this.getByteAt(offset + 3);
+        let iLong = isBigEndian
+            ? (((((iByte1 << 8) + iByte2) << 8) + iByte3) << 8) + iByte4
+            : (((((iByte4 << 8) + iByte3) << 8) + iByte2) << 8) + iByte1;
+        if (iLong < 0) {
+            iLong += 4294967296;
+        }
+        return iLong;
+    }
+    getSLongAt(offset, isBigEndian) {
+        const iULong = this.getLongAt(offset, isBigEndian);
+        if (iULong > 2147483647) {
+            return iULong - 4294967296;
+        }
+        else {
+            return iULong;
+        }
+    }
+    getInteger24At(offset, isBigEndian) {
+        const iByte1 = this.getByteAt(offset), iByte2 = this.getByteAt(offset + 1), iByte3 = this.getByteAt(offset + 2);
+        let iInteger = isBigEndian
+            ? (((iByte1 << 8) + iByte2) << 8) + iByte3
+            : (((iByte3 << 8) + iByte2) << 8) + iByte1;
+        if (iInteger < 0) {
+            iInteger += 16777216;
+        }
+        return iInteger;
+    }
+    getStringAt(offset, length) {
+        const string = [];
+        for (let i = offset, j = 0; i < offset + length; i++, j++) {
+            string[j] = String.fromCharCode(this.getByteAt(i));
+        }
+        return string.join("");
+    }
+    getStringWithCharsetAt(offset, length, charset) {
+        const bytes = this.getBytesAt(offset, length);
+        let string;
+        switch ((charset || "").toLowerCase()) {
+            case "utf-16":
+            case "utf-16le":
+            case "utf-16be":
+                string = StringUtils.readUTF16String(bytes, charset === "utf-16be");
+                break;
+            case "utf-8":
+                string = StringUtils.readUTF8String(bytes);
+                break;
+            default:
+                string = StringUtils.readNullTerminatedString(bytes);
+                break;
+        }
+        return string;
+    }
+    getCharAt(offset) {
+        return String.fromCharCode(this.getByteAt(offset));
+    }
+    /**
+     * The ID3v2 tag/frame size is encoded with four bytes where the most
+     * significant bit (bit 7) is set to zero in every byte, making a total of 28
+     * bits. The zeroed bits are ignored, so a 257 bytes long tag is represented
+     * as $00 00 02 01.
+     */
+    getSynchsafeInteger32At(offset) {
+        const size1 = this.getByteAt(offset);
+        const size2 = this.getByteAt(offset + 1);
+        const size3 = this.getByteAt(offset + 2);
+        const size4 = this.getByteAt(offset + 3);
+        const size = size4 & 0x7f |
+            ((size3 & 0x7f) << 7) |
+            ((size2 & 0x7f) << 14) |
+            ((size1 & 0x7f) << 21);
+        return size;
+    }
+}
+module.exports = MediaFileReader;

package/build/MediaTagReader.d.ts

@@ -0,0 +1,18 @@
+declare const MediaFileReader: any;
+import type { CallbackType, LoadCallbackType, ByteRange, TagType } from "./types";
+declare class MediaTagReader {
+    private _mediaFileReader;
+    private _tags;
+    constructor(mediaFileReader: InstanceType<typeof MediaFileReader>);
+    static getTagIdentifierByteRange(): ByteRange;
+    static canReadTagFormat(_tagIdentifier: Array<number>): boolean;
+    setTagsToRead(tags: string[] | null): this;
+    read(callbacks: CallbackType<TagType>): void;
+    read(): Promise<TagType>;
+    readAsync(): Promise<TagType>;
+    getShortcuts(): Record<string, string | string[]>;
+    _loadData(_mediaFileReader: InstanceType<typeof MediaFileReader>, _callbacks: LoadCallbackType): void;
+    _parseData(_mediaFileReader: InstanceType<typeof MediaFileReader>, _tags: string[] | null): TagType;
+    _expandShortcutTags(tagsWithShortcuts: string[] | null): string[] | null;
+}
+export = MediaTagReader;

package/build/MediaTagReader.js

@@ -0,0 +1,76 @@
+"use strict";
+const MediaFileReader = require("./MediaFileReader");
+class MediaTagReader {
+    constructor(mediaFileReader) {
+        this._mediaFileReader = mediaFileReader;
+        this._tags = null;
+    }
+    static getTagIdentifierByteRange() {
+        throw new Error("Must implement");
+    }
+    static canReadTagFormat(_tagIdentifier) {
+        throw new Error("Must implement");
+    }
+    setTagsToRead(tags) {
+        this._tags = tags;
+        return this;
+    }
+    read(callbacks) {
+        if (callbacks === undefined) {
+            return new Promise((resolve, reject) => {
+                this.read({ onSuccess: resolve, onError: reject });
+            });
+        }
+        const self = this;
+        this._mediaFileReader.init({
+            onSuccess: function () {
+                self._loadData(self._mediaFileReader, {
+                    onSuccess: function () {
+                        let tags;
+                        try {
+                            tags = self._parseData(self._mediaFileReader, self._tags);
+                        }
+                        catch (ex) {
+                            const err = ex;
+                            if (callbacks.onError) {
+                                callbacks.onError({
+                                    type: "parseData",
+                                    info: err.message,
+                                });
+                            }
+                            return;
+                        }
+                        callbacks.onSuccess(tags);
+                    },
+                    onError: callbacks.onError,
+                });
+            },
+            onError: callbacks.onError,
+        });
+    }
+    readAsync() {
+        return this.read();
+    }
+    getShortcuts() {
+        return {};
+    }
+    _loadData(_mediaFileReader, _callbacks) {
+        throw new Error("Must implement _loadData function");
+    }
+    _parseData(_mediaFileReader, _tags) {
+        throw new Error("Must implement _parseData function");
+    }
+    _expandShortcutTags(tagsWithShortcuts) {
+        if (!tagsWithShortcuts) {
+            return null;
+        }
+        let tags = [];
+        const shortcuts = this.getShortcuts();
+        for (let i = 0, tagOrShortcut; (tagOrShortcut = tagsWithShortcuts[i]); i++) {
+            tags = tags.concat(shortcuts[tagOrShortcut] ||
+                [tagOrShortcut]);
+        }
+        return tags;
+    }
+}
+module.exports = MediaTagReader;

package/build/NodeFileReader.d.ts

@@ -0,0 +1,12 @@
+declare const MediaFileReader: any;
+import type { LoadCallbackType } from "./types";
+declare class NodeFileReader extends MediaFileReader {
+    private _path;
+    private _fileData;
+    constructor(path: string);
+    static canReadFile(file: unknown): boolean;
+    getByteAt(offset: number): number;
+    _init(callbacks: LoadCallbackType): void;
+    loadRange(range: [number, number], callbacks: LoadCallbackType): void;
+}
+export = NodeFileReader;