@probityrules/jsmediatags 4.0.0

package/build/ID3v2TagContents.js

@@ -0,0 +1,318 @@
+'use strict';
+const ByteArrayUtils = require('./ByteArrayUtils');
+const bin = ByteArrayUtils.bin;
+const getSynchsafeInteger32 = ByteArrayUtils.getSynchsafeInteger32;
+const getInteger32 = ByteArrayUtils.getInteger32;
+const getInteger24 = ByteArrayUtils.getInteger24;
+// Offsets
+const FLAGS = 5;
+const SIZE = 6;
+const EXTENDED_HEADER = 10;
+const EXTENDED_FLAGS_V3 = 14;
+const EXTENDED_FLAGS_V4 = 15;
+const START_EXTENDED_DATA_V3 = 20;
+const START_EXTENDED_DATA_V4 = 16;
+// Sizes
+const HEADER_SIZE = 10;
+class ID3v2TagContents {
+    constructor(major, revision) {
+        if (major < 2 || major > 4) {
+            throw new Error('Major version not supported');
+        }
+        this._major = major;
+        this._revision = revision;
+        this._contents = [].concat(bin("ID3"), [major, revision], [0], [0, 0, 0, 0]);
+        this._frames = {};
+        this._updateSize();
+        this._extendedHeader = {
+            UPDATE: 0,
+            CRC: 0,
+            RESTRICTIONS: 0,
+        };
+    }
+    toArray() {
+        return this._contents.slice(0);
+    }
+    setFlags(flags) {
+        return this._updateFlags(flags, 0);
+    }
+    _updateFlags(flags, binaryFlags) {
+        if (typeof binaryFlags !== 'number') {
+            binaryFlags = this._contents[FLAGS] || 0;
+        }
+        function setOrUnsetBit(shouldSet, bitmap, bit) {
+            if (shouldSet) {
+                return bitmap |= 1 << bit;
+            }
+            else {
+                return bitmap &= ~(1 << bit);
+            }
+        }
+        if (flags.hasOwnProperty('unsynchronisation')) {
+            binaryFlags = setOrUnsetBit(!!flags.unsynchronisation, binaryFlags, 7);
+        }
+        if (flags.hasOwnProperty('extended_header')) {
+            binaryFlags = setOrUnsetBit(!!flags.extended_header, binaryFlags, 6);
+        }
+        if (flags.hasOwnProperty('experimental_indicator')) {
+            binaryFlags = setOrUnsetBit(!!flags.experimental_indicator, binaryFlags, 5);
+        }
+        if (flags.hasOwnProperty('footer_present')) {
+            binaryFlags = setOrUnsetBit(!!flags.footer_present, binaryFlags, 4);
+        }
+        this._contents[FLAGS] = binaryFlags;
+        return this;
+    }
+    setCrc(crc) {
+        if (!this._hasExtendedHeader) {
+            this._initExtendedHeader();
+        }
+        if (this._major === 3) {
+            this._setBitAtOffset(EXTENDED_FLAGS_V3, 7);
+            this._setData(START_EXTENDED_DATA_V3, crc);
+            this._extendedHeader['CRC'] = crc.length;
+            // Update extended header size.
+            this._setData(EXTENDED_HEADER, getInteger32(10));
+        }
+        else if (this._major === 4) {
+            this._setBitAtOffset(EXTENDED_FLAGS_V4, 5);
+            this._addExtendedHeaderData('CRC', crc);
+        }
+        this._updateSize();
+        return this;
+    }
+    setTagIsUpdate() {
+        if (!this._hasExtendedHeader) {
+            this._initExtendedHeader();
+        }
+        if (this._major === 4) {
+            this._setBitAtOffset(EXTENDED_FLAGS_V4, 6);
+        }
+        this._updateSize();
+        return this;
+    }
+    /**
+     * For some applications it might be desired to restrict a tag in more
+     * ways than imposed by the ID3v2 specification. Note that the
+     * presence of these restrictions does not affect how the tag is
+     * decoded, merely how it was restricted before encoding. If this flag
+     * is set the tag is restricted as follows:
+     *
+     *    Flag data length       $01
+     *    Restrictions           %ppqrrstt
+     *
+     * p - Tag size restrictions
+  
+     *   00   No more than 128 frames and 1 MB total tag size.
+     *   01   No more than 64 frames and 128 KB total tag size.
+     *   10   No more than 32 frames and 40 KB total tag size.
+     *   11   No more than 32 frames and 4 KB total tag size.
+     *
+     * q - Text encoding restrictions
+     *
+     *   0    No restrictions
+     *   1    Strings are only encoded with ISO-8859-1 [ISO-8859-1] or
+     *        UTF-8 [UTF-8].
+     *
+     * r - Text fields size restrictions
+     *
+     *   00   No restrictions
+     *   01   No string is longer than 1024 characters.
+     *   10   No string is longer than 128 characters.
+     *   11   No string is longer than 30 characters.
+     *
+     *   Note that nothing is said about how many bytes is used to
+     *   represent those characters, since it is encoding dependent. If a
+     *   text frame consists of more than one string, the sum of the
+     *   strungs is restricted as stated.
+     *
+     * s - Image encoding restrictions
+     *
+     *   0   No restrictions
+     *   1   Images are encoded only with PNG [PNG] or JPEG [JFIF].
+     *
+     * t - Image size restrictions
+     *
+     *   00  No restrictions
+     *   01  All images are 256x256 pixels or smaller.
+     *   10  All images are 64x64 pixels or smaller.
+     *   11  All images are exactly 64x64 pixels, unless required
+     *       otherwise.
+     */
+    setTagRestrictions(size, textEncoding, textSize, imageEncoding, imageSize) {
+        if (!this._hasExtendedHeader) {
+            this._initExtendedHeader();
+        }
+        if (this._major === 4) {
+            this._setBitAtOffset(EXTENDED_FLAGS_V4, 4);
+            // 0x03 = 0b11
+            this._addExtendedHeaderData('RESTRICTIONS', [
+                (size & 0x3) << 6 |
+                    (textEncoding & 0x1) << 5 |
+                    (textSize & 0x3) << 3 |
+                    (imageEncoding & 0x1) << 2 |
+                    (imageSize & 0x3) << 1
+            ]);
+        }
+        this._updateSize();
+        return this;
+    }
+    /**
+     * noFlagsDataLength - The data length if all flags were set to 0,
+     *   for instance, the length before compression and unsynchronisation.
+     *   This field is only needed when data_length_indicator flag is set.
+     */
+    addFrame(id, data, flags, noFlagsDataLength) {
+        var _a, _b;
+        var size = 0;
+        var frameFlags = [0, 0];
+        if (flags) {
+            flags.message = (_a = flags.message) !== null && _a !== void 0 ? _a : {
+                tag_alter_preservation: false,
+                file_alter_preservation: false,
+                read_only: false,
+            };
+            flags.format = (_b = flags.format) !== null && _b !== void 0 ? _b : {
+                grouping_identity: false,
+                compression: false,
+                encryption: false,
+                unsynchronisation: false,
+                data_length_indicator: false,
+            };
+        }
+        data = data || [];
+        var dataLength = data.length;
+        var isTagUnsynchronised = this._contents[FLAGS] & (1 << 7);
+        if (isTagUnsynchronised) {
+            var unsynchronisedByteCount = 0;
+            for (var i = 0; i < data.length - 1; i++) {
+                if (data[i] === 0xff && data[i + 1] === 0x00) {
+                    unsynchronisedByteCount++;
+                }
+            }
+            dataLength -= unsynchronisedByteCount;
+        }
+        if (this._major === 2) {
+            size = getInteger24(dataLength);
+        }
+        else if (this._major === 3) {
+            size = getInteger32(dataLength);
+            if (flags) {
+                frameFlags[0] |= (flags.message.tag_alter_preservation ? 1 : 0) << 7;
+                frameFlags[0] |= (flags.message.file_alter_preservation ? 1 : 0) << 6;
+                frameFlags[0] |= (flags.message.read_only ? 1 : 0) << 5;
+                frameFlags[1] |= (flags.format.compression ? 1 : 0) << 7;
+                frameFlags[1] |= (flags.format.encryption ? 1 : 0) << 6;
+                frameFlags[1] |= (flags.format.grouping_identity ? 1 : 0) << 5;
+            }
+        }
+        else if (this._major === 4) {
+            if (flags) {
+                frameFlags[0] |= (flags.message.tag_alter_preservation ? 1 : 0) << 6;
+                frameFlags[0] |= (flags.message.file_alter_preservation ? 1 : 0) << 5;
+                frameFlags[0] |= (flags.message.read_only ? 1 : 0) << 4;
+                frameFlags[1] |= (flags.format.grouping_identity ? 1 : 0) << 6;
+                frameFlags[1] |= (flags.format.compression ? 1 : 0) << 3;
+                frameFlags[1] |= (flags.format.encryption ? 1 : 0) << 2;
+                frameFlags[1] |= (flags.format.unsynchronisation ? 1 : 0) << 1;
+                frameFlags[1] |= flags.format.data_length_indicator ? 1 : 0;
+                if (flags.format.data_length_indicator) {
+                    dataLength += 4;
+                }
+            }
+            size = getSynchsafeInteger32(dataLength);
+        }
+        else {
+            throw Error("Major version not supported");
+        }
+        var frame = [].concat(bin(id), size, frameFlags, flags && flags.format.data_length_indicator && noFlagsDataLength
+            ? getSynchsafeInteger32(noFlagsDataLength)
+            : [], data);
+        if (!this._frames[id]) {
+            this._frames[id] = [];
+        }
+        this._frames[id].push(frame);
+        this._addData(this._nextFrameOffset, frame);
+        this._updateSize();
+        return this;
+    }
+    _addExtendedHeaderData(tagKey, tagData) {
+        var offset = START_EXTENDED_DATA_V4;
+        // Each flag that is set in the extended header has data attached, which
+        // comes in the order in which the flags are encountered (i.e. the data
+        // for flag 'b' comes before the data for flag 'c').
+        // _extendedHeader keeps track of which tag data we have by storing the
+        // size of the data. To know where to add a particular tag data we just need
+        // to sum all the data lengths of the tags that come before this tagKey
+        // because the keys in the map are in order.
+        for (var key in this._extendedHeader) {
+            if (this._extendedHeader.hasOwnProperty(key)) {
+                if (key === tagKey) {
+                    break;
+                }
+                else {
+                    offset += this._extendedHeader[key];
+                }
+            }
+        }
+        var data = [].concat([tagData.length], tagData);
+        this._extendedHeader[tagKey] = data.length;
+        this._addData(offset, data);
+    }
+    _initExtendedHeader() {
+        this._hasExtendedHeader = true;
+        this._updateFlags({ extended_header: true });
+        if (this._major === 3) {
+            this._addData(EXTENDED_HEADER, [
+                0, 0, 0, 6, // size
+                0, 0, // flags
+                0, 0, 0, 0 // padding
+            ]);
+        }
+        else if (this._major === 4) {
+            this._addData(EXTENDED_HEADER, [].concat(getSynchsafeInteger32(6), [1], [0]));
+        }
+        else {
+            throw new Error("Version doesn't support extended header.");
+        }
+    }
+    _updateSize() {
+        // Header (10 bytes) is not included in the size.
+        var size = 0;
+        if (this._hasExtendedHeader) {
+            // Extended header size
+            size += this._major === 4 ? 6 : 10;
+            // Extended header data size
+            for (var key in this._extendedHeader) {
+                if (this._extendedHeader.hasOwnProperty(key)) {
+                    size += this._extendedHeader[key];
+                }
+            }
+        }
+        for (var frameId in this._frames) {
+            if (this._frames.hasOwnProperty(frameId)) {
+                for (var i = 0, frame; frame = this._frames[frameId][i]; i++) {
+                    size += frame.length;
+                }
+            }
+        }
+        this._nextFrameOffset = size + HEADER_SIZE;
+        this._size = size;
+        this._setData(SIZE, getSynchsafeInteger32(size));
+    }
+    _setBitAtOffset(offset, bit) {
+        var data = this._getData(offset, 1);
+        data[0] |= 1 << bit;
+        this._setData(offset, data);
+    }
+    _getData(offset, length) {
+        return this._contents.slice(offset, offset + length);
+    }
+    _setData(offset, data) {
+        this._contents.splice(offset, data.length, ...data);
+    }
+    _addData(offset, data) {
+        this._contents.splice(offset, 0, ...data);
+    }
+}
+module.exports = ID3v2TagContents;

package/build/ID3v2TagReader.d.ts

@@ -0,0 +1,13 @@
+declare const MediaTagReader: any;
+declare const MediaFileReader: any;
+import type { TagFrames, ByteRange, TagType } from "./types";
+import type { LoadCallbackType } from "./types";
+declare class ID3v2TagReader extends MediaTagReader {
+    static getTagIdentifierByteRange(): ByteRange;
+    static canReadTagFormat(tagIdentifier: Array<number>): boolean;
+    _loadData(mediaFileReader: InstanceType<typeof MediaFileReader>, callbacks: LoadCallbackType): void;
+    _parseData(data: InstanceType<typeof MediaFileReader>, tags: string[] | null): TagType;
+    _getFrameData(frames: TagFrames, ids: string[]): unknown;
+    getShortcuts(): Record<string, string | string[]>;
+}
+export = ID3v2TagReader;

package/build/ID3v2TagReader.js

@@ -0,0 +1,118 @@
+"use strict";
+const MediaTagReader = require("./MediaTagReader");
+const MediaFileReader = require("./MediaFileReader");
+const ID3v2FrameReader = require("./ID3v2FrameReader");
+const ID3_HEADER_SIZE = 10;
+class ID3v2TagReader extends MediaTagReader {
+    static getTagIdentifierByteRange() {
+        return {
+            offset: 0,
+            length: ID3_HEADER_SIZE,
+        };
+    }
+    static canReadTagFormat(tagIdentifier) {
+        const id = String.fromCharCode.apply(String, tagIdentifier.slice(0, 3));
+        return id === "ID3";
+    }
+    _loadData(mediaFileReader, callbacks) {
+        mediaFileReader.loadRange([6, 9], {
+            onSuccess: function () {
+                mediaFileReader.loadRange([
+                    0,
+                    ID3_HEADER_SIZE + mediaFileReader.getSynchsafeInteger32At(6) - 1,
+                ], callbacks);
+            },
+            onError: callbacks.onError,
+        });
+    }
+    _parseData(data, tags) {
+        let offset = 0;
+        const major = data.getByteAt(offset + 3);
+        if (major > 4) {
+            return { type: "ID3", tags: { version: ">2.4" } };
+        }
+        const revision = data.getByteAt(offset + 4);
+        const unsynch = data.isBitSetAt(offset + 5, 7);
+        const xheader = data.isBitSetAt(offset + 5, 6);
+        const xindicator = data.isBitSetAt(offset + 5, 5);
+        const size = data.getSynchsafeInteger32At(offset + 6);
+        offset += 10;
+        if (xheader) {
+            if (major === 4) {
+                const xheadersize = data.getSynchsafeInteger32At(offset);
+                offset += xheadersize;
+            }
+            else {
+                const xheadersize = data.getLongAt(offset, true);
+                offset += xheadersize + 4;
+            }
+        }
+        const id3 = {
+            type: "ID3",
+            version: "2." + major + "." + revision,
+            major: major,
+            revision: revision,
+            flags: {
+                unsynchronisation: unsynch,
+                extended_header: xheader,
+                experimental_indicator: xindicator,
+                footer_present: false,
+            },
+            size: size,
+            tags: {},
+        };
+        let expandedTags;
+        if (tags) {
+            expandedTags = this._expandShortcutTags(tags);
+        }
+        let offsetEnd = size + 10;
+        let reader = data;
+        if (id3.flags.unsynchronisation) {
+            reader = ID3v2FrameReader.getUnsyncFileReader(reader, offset, size);
+            offset = 0;
+            offsetEnd = reader.getSize();
+        }
+        const frames = ID3v2FrameReader.readFrames(offset, offsetEnd, reader, id3, expandedTags !== null && expandedTags !== void 0 ? expandedTags : undefined);
+        for (const name in SHORTCUTS) {
+            if (SHORTCUTS.hasOwnProperty(name)) {
+                const frameData = this._getFrameData(frames, SHORTCUTS[name]);
+                if (frameData) {
+                    id3.tags[name] = frameData;
+                }
+            }
+        }
+        for (const frame in frames) {
+            if (frames.hasOwnProperty(frame)) {
+                id3.tags[frame] = frames[frame];
+            }
+        }
+        return id3;
+    }
+    _getFrameData(frames, ids) {
+        let frame;
+        for (let i = 0, id; (id = ids[i]); i++) {
+            if (id in frames) {
+                frame = frames[id];
+                if (Array.isArray(frame)) {
+                    frame = frame[0];
+                }
+                return frame.data;
+            }
+        }
+    }
+    getShortcuts() {
+        return SHORTCUTS;
+    }
+}
+const SHORTCUTS = {
+    title: ["TIT2", "TT2"],
+    artist: ["TPE1", "TP1"],
+    album: ["TALB", "TAL"],
+    year: ["TYER", "TYE"],
+    comment: ["COMM", "COM"],
+    track: ["TRCK", "TRK"],
+    genre: ["TCON", "TCO"],
+    picture: ["APIC", "PIC"],
+    lyrics: ["USLT", "ULT"],
+};
+module.exports = ID3v2TagReader;

package/build/MP4TagContents.d.ts

@@ -0,0 +1,17 @@
+import type { ByteArray } from './types';
+declare class MP4TagContents {
+    _atoms: Array<Atom>;
+    constructor(ftyp: string, atoms?: Array<Atom>);
+    toArray(): ByteArray;
+    static createAtom(atomName: string): Atom;
+    static createContainerAtom(atomName: string, atoms: Array<Atom>, data?: ByteArray): Atom;
+    static createMetadataAtom(atomName: string, type: string, data: ByteArray): Atom;
+}
+declare class Atom {
+    _name: string;
+    _data: Array<number>;
+    _atoms: Array<Atom>;
+    constructor(name: string, data?: ByteArray | null, atoms?: Array<Atom> | null);
+    toArray(): ByteArray;
+}
+export = MP4TagContents;

package/build/MP4TagContents.js

@@ -0,0 +1,52 @@
+'use strict';
+const ByteArrayUtils = require('./ByteArrayUtils');
+const bin = ByteArrayUtils.bin;
+const pad = ByteArrayUtils.pad;
+const getInteger32 = ByteArrayUtils.getInteger32;
+class MP4TagContents {
+    constructor(ftyp, atoms) {
+        this._atoms = [
+            new Atom("ftyp", pad(bin(ftyp), 24))
+        ].concat(atoms || []);
+    }
+    toArray() {
+        return this._atoms.reduce(function (array, atom) {
+            return array.concat(atom.toArray());
+        }, []);
+    }
+    static createAtom(atomName) {
+        return new Atom(atomName);
+    }
+    static createContainerAtom(atomName, atoms, data) {
+        return new Atom(atomName, data !== null && data !== void 0 ? data : null, atoms !== null && atoms !== void 0 ? atoms : null);
+    }
+    static createMetadataAtom(atomName, type, data) {
+        var _a;
+        const klassMap = {
+            uint8: 0,
+            uint8b: 21,
+            text: 1,
+            jpeg: 13,
+            png: 14,
+        };
+        var klass = (_a = klassMap[type]) !== null && _a !== void 0 ? _a : 0;
+        return this.createContainerAtom(atomName, [
+            new Atom("data", [].concat([0x00, 0x00, 0x00, klass], [0x00, 0x00, 0x00, 0x00], data)),
+        ]);
+    }
+}
+class Atom {
+    constructor(name, data, atoms) {
+        this._name = name;
+        this._data = data || [];
+        this._atoms = atoms || [];
+    }
+    toArray() {
+        var atomsArray = this._atoms.reduce(function (array, atom) {
+            return array.concat(atom.toArray());
+        }, []);
+        var length = 4 + this._name.length + this._data.length + atomsArray.length;
+        return [].concat(getInteger32(length), bin(this._name), this._data, atomsArray);
+    }
+}
+module.exports = MP4TagContents;

package/build/MP4TagReader.d.ts

@@ -0,0 +1,19 @@
+declare const MediaTagReader: any;
+declare const MediaFileReader: any;
+import type { LoadCallbackType, ByteRange, TagType, TagFrame } from './types';
+type MediaReader = InstanceType<typeof MediaFileReader>;
+declare class MP4TagReader extends MediaTagReader {
+    static getTagIdentifierByteRange(): ByteRange;
+    static canReadTagFormat(tagIdentifier: Array<number>): boolean;
+    _loadData(mediaFileReader: MediaReader, callbacks: LoadCallbackType): void;
+    _loadAtom(mediaFileReader: MediaReader, offset: number, parentAtomFullName: string, callbacks: LoadCallbackType): void;
+    _isContainerAtom(atomName: string): boolean;
+    _canReadAtom(atomName: string): boolean;
+    _parseData(data: MediaReader, tagsToRead: Array<string> | null): TagType;
+    _readAtom(tags: Record<string, unknown>, data: MediaReader, offset: number, length: number, tagsToRead: Array<string> | null, parentAtomFullName?: string, indent?: string): void;
+    _readMetadataAtom(data: MediaReader, offset: number): TagFrame;
+    getShortcuts(): {
+        [key: string]: string | Array<string>;
+    };
+}
+export = MP4TagReader;