q-fi-core 2.3.1

package/dist/lib/metaflac-js.d.ts

@@ -0,0 +1,124 @@
+/// <reference types="node" />
+declare class Metaflac {
+    buffer: Buffer;
+    marker: string;
+    streamInfo: any;
+    blocks: any[];
+    padding: any;
+    vorbisComment: any;
+    vendorString: string;
+    tags: any;
+    pictures: Buffer[];
+    picturesSpecs: object[];
+    picturesDatas: string[];
+    framesOffset: number;
+    constructor(flac: Buffer);
+    init(): void;
+    parseVorbisComment(): void;
+    parsePictureBlock(): void;
+    getPicturesSpecs(): object[];
+    /**
+     * Get the MD5 signature from the STREAMINFO block.
+     */
+    getMd5sum(): any;
+    /**
+     * Get the minimum block size from the STREAMINFO block.
+     */
+    getMinBlocksize(): any;
+    /**
+     * Get the maximum block size from the STREAMINFO block.
+     */
+    getMaxBlocksize(): any;
+    /**
+     * Get the minimum frame size from the STREAMINFO block.
+     */
+    getMinFramesize(): any;
+    /**
+     * Get the maximum frame size from the STREAMINFO block.
+     */
+    getMaxFramesize(): any;
+    /**
+     * Get the sample rate from the STREAMINFO block.
+     */
+    getSampleRate(): number;
+    /**
+     * Get the number of channels from the STREAMINFO block.
+     */
+    getChannels(): number;
+    /**
+     * Get the # of bits per sample from the STREAMINFO block.
+     */
+    getBps(): number;
+    /**
+     * Get the total # of samples from the STREAMINFO block.
+     */
+    getTotalSamples(): number;
+    /**
+     * Show the vendor string from the VORBIS_COMMENT block.
+     */
+    getVendorTag(): string;
+    /**
+     * Get all tags where the the field name matches NAME.
+     *
+     * @param {string} name
+     */
+    getTag(name: string): any;
+    /**
+     * Remove all tags whose field name is NAME.
+     *
+     * @param {string} name
+     */
+    removeTag(name: string): void;
+    /**
+     * Remove first tag whose field name is NAME.
+     *
+     * @param {string} name
+     */
+    removeFirstTag(name: string): void;
+    /**
+     * Remove all tags, leaving only the vendor string.
+     */
+    removeAllTags(): void;
+    /**
+     * Add a tag.
+     * The FIELD must comply with the Vorbis comment spec, of the form NAME=VALUE. If there is currently no tag block, one will be created.
+     *
+     * @param {string} field
+     */
+    setTag(field: string): void;
+    /**
+     * Import a picture and store it in a PICTURE metadata block.
+     *
+     * @param {string} filename
+     */
+    importPicture(picture: Buffer, dimension: number, mime: 'image/jpeg' | 'image/png'): void;
+    /**
+     * Return all tags.
+     */
+    getAllTags(): any;
+    buildSpecification(spec?: {}): {
+        type: number;
+        mime: string;
+        description: string;
+        width: number;
+        height: number;
+        depth: number;
+        colors: number;
+    };
+    /**
+     * Build a picture block.
+     *
+     * @param {Buffer} picture
+     * @param {Object} specification
+     * @returns {Buffer}
+     */
+    buildPictureBlock(picture: Buffer, specification?: any): Buffer;
+    buildMetadataBlock(type: number, block: Buffer, isLast?: boolean): Buffer;
+    buildMetadata(): Buffer[];
+    buildStream(): Buffer[];
+    /**
+     * Save changes to buffer and return changed buffer
+     */
+    getBuffer(): Buffer;
+}
+export default Metaflac;

package/dist/lib/metaflac-js.js

@@ -0,0 +1,343 @@
+"use strict";
+// const BLOCK_TYPE = {
+//   0: 'STREAMINFO',
+//   1: 'PADDING',
+//   2: 'APPLICATION',
+//   3: 'SEEKTABLE',
+//   4: 'VORBIS_COMMENT', // There may be only one VORBIS_COMMENT block in a stream.
+//   5: 'CUESHEET',
+//   6: 'PICTURE',
+// };
+Object.defineProperty(exports, "__esModule", { value: true });
+const STREAMINFO = 0;
+const PADDING = 1;
+const APPLICATION = 2;
+const SEEKTABLE = 3;
+const VORBIS_COMMENT = 4;
+const CUESHEET = 5;
+const PICTURE = 6;
+const formatVorbisComment = (vendorString, commentList) => {
+    const bufferArray = [];
+    const vendorStringBuffer = Buffer.from(vendorString, 'utf8');
+    const vendorLengthBuffer = Buffer.alloc(4);
+    vendorLengthBuffer.writeUInt32LE(vendorStringBuffer.length);
+    const userCommentListLengthBuffer = Buffer.alloc(4);
+    userCommentListLengthBuffer.writeUInt32LE(commentList.length);
+    bufferArray.push(vendorLengthBuffer, vendorStringBuffer, userCommentListLengthBuffer);
+    for (let i = 0; i < commentList.length; i++) {
+        const comment = commentList[i];
+        const commentBuffer = Buffer.from(comment, 'utf8');
+        const lengthBuffer = Buffer.alloc(4);
+        lengthBuffer.writeUInt32LE(commentBuffer.length);
+        bufferArray.push(lengthBuffer, commentBuffer);
+    }
+    return Buffer.concat(bufferArray);
+};
+class Metaflac {
+    constructor(flac) {
+        this.buffer = flac;
+        this.marker = '';
+        this.streamInfo = null;
+        this.blocks = [];
+        this.padding = null;
+        this.vorbisComment = null;
+        this.vendorString = '';
+        this.tags = [];
+        this.pictures = [];
+        this.picturesSpecs = [];
+        this.picturesDatas = [];
+        this.framesOffset = 0;
+        this.init();
+    }
+    init() {
+        let offset = 4;
+        let blockType = 0;
+        let isLastBlock = false;
+        while (!isLastBlock) {
+            blockType = this.buffer.readUInt8(offset++);
+            isLastBlock = blockType >= 128;
+            blockType = blockType % 128;
+            const blockLength = this.buffer.readUIntBE(offset, 3);
+            offset += 3;
+            if (blockType === STREAMINFO) {
+                this.streamInfo = this.buffer.slice(offset, offset + blockLength);
+            }
+            if (blockType === VORBIS_COMMENT) {
+                this.vorbisComment = this.buffer.slice(offset, offset + blockLength);
+                this.parseVorbisComment();
+            }
+            if ([APPLICATION, SEEKTABLE, CUESHEET].includes(blockType)) {
+                this.blocks.push([blockType, this.buffer.slice(offset, offset + blockLength)]);
+            }
+            offset += blockLength;
+        }
+        this.framesOffset = offset;
+    }
+    parseVorbisComment() {
+        const vendorLength = this.vorbisComment.readUInt32LE(0);
+        this.vendorString = this.vorbisComment.slice(4, vendorLength + 4).toString('utf8');
+    }
+    parsePictureBlock() {
+        this.pictures.forEach((picture) => {
+            let offset = 0;
+            const type = picture.readUInt32BE(offset);
+            offset += 4;
+            const mimeTypeLength = picture.readUInt32BE(offset);
+            offset += 4;
+            const mime = picture.slice(offset, offset + mimeTypeLength).toString('ascii');
+            offset += mimeTypeLength;
+            const descriptionLength = picture.readUInt32BE(offset);
+            offset += 4;
+            const description = picture.slice(offset, (offset += descriptionLength)).toString('utf8');
+            const width = picture.readUInt32BE(offset);
+            offset += 4;
+            const height = picture.readUInt32BE(offset);
+            offset += 4;
+            const depth = picture.readUInt32BE(offset);
+            offset += 4;
+            const colors = picture.readUInt32BE(offset);
+            offset += 4;
+            const pictureDataLength = picture.readUInt32BE(offset);
+            offset += 4;
+            this.picturesDatas.push(picture.slice(offset, offset + pictureDataLength));
+            this.picturesSpecs.push(this.buildSpecification({
+                type,
+                mime,
+                description,
+                width,
+                height,
+                depth,
+                colors,
+            }));
+        });
+    }
+    getPicturesSpecs() {
+        return this.picturesSpecs;
+    }
+    /**
+     * Get the MD5 signature from the STREAMINFO block.
+     */
+    getMd5sum() {
+        return this.streamInfo.slice(18, 34).toString('hex');
+    }
+    /**
+     * Get the minimum block size from the STREAMINFO block.
+     */
+    getMinBlocksize() {
+        return this.streamInfo.readUInt16BE(0);
+    }
+    /**
+     * Get the maximum block size from the STREAMINFO block.
+     */
+    getMaxBlocksize() {
+        return this.streamInfo.readUInt16BE(2);
+    }
+    /**
+     * Get the minimum frame size from the STREAMINFO block.
+     */
+    getMinFramesize() {
+        return this.streamInfo.readUIntBE(4, 3);
+    }
+    /**
+     * Get the maximum frame size from the STREAMINFO block.
+     */
+    getMaxFramesize() {
+        return this.streamInfo.readUIntBE(7, 3);
+    }
+    /**
+     * Get the sample rate from the STREAMINFO block.
+     */
+    getSampleRate() {
+        // 20 bits number
+        return this.streamInfo.readUIntBE(10, 3) >> 4;
+    }
+    /**
+     * Get the number of channels from the STREAMINFO block.
+     */
+    getChannels() {
+        // 3 bits
+        return this.streamInfo.readUIntBE(10, 3) & (0x00000f >> 1);
+    }
+    /**
+     * Get the # of bits per sample from the STREAMINFO block.
+     */
+    getBps() {
+        return this.streamInfo.readUIntBE(12, 2) & (0x01f0 >> 4);
+    }
+    /**
+     * Get the total # of samples from the STREAMINFO block.
+     */
+    getTotalSamples() {
+        return this.streamInfo.readUIntBE(13, 5) & 0x0fffffffff;
+    }
+    /**
+     * Show the vendor string from the VORBIS_COMMENT block.
+     */
+    getVendorTag() {
+        return this.vendorString;
+    }
+    /**
+     * Get all tags where the the field name matches NAME.
+     *
+     * @param {string} name
+     */
+    getTag(name) {
+        return this.tags
+            .filter((item) => {
+            const itemName = item.split('=')[0];
+            return itemName === name;
+        })
+            .join('\n');
+    }
+    /**
+     * Remove all tags whose field name is NAME.
+     *
+     * @param {string} name
+     */
+    removeTag(name) {
+        this.tags = this.tags.filter((item) => {
+            const itemName = item.split('=')[0];
+            return itemName !== name;
+        });
+    }
+    /**
+     * Remove first tag whose field name is NAME.
+     *
+     * @param {string} name
+     */
+    removeFirstTag(name) {
+        const found = this.tags.findIndex((item) => {
+            return item.split('=')[0] === name;
+        });
+        if (found !== -1) {
+            this.tags.splice(found, 1);
+        }
+    }
+    /**
+     * Remove all tags, leaving only the vendor string.
+     */
+    removeAllTags() {
+        this.tags = [];
+    }
+    /**
+     * Add a tag.
+     * The FIELD must comply with the Vorbis comment spec, of the form NAME=VALUE. If there is currently no tag block, one will be created.
+     *
+     * @param {string} field
+     */
+    setTag(field) {
+        if (field.indexOf('=') === -1) {
+            throw new Error(`malformed vorbis comment field "${field}", field contains no '=' character`);
+        }
+        this.tags.push(field);
+    }
+    /**
+     * Import a picture and store it in a PICTURE metadata block.
+     *
+     * @param {string} filename
+     */
+    importPicture(picture, dimension, mime) {
+        const spec = this.buildSpecification({
+            mime,
+            width: dimension,
+            height: dimension,
+        });
+        this.pictures.push(this.buildPictureBlock(picture, spec));
+        this.picturesSpecs.push(spec);
+    }
+    /**
+     * Return all tags.
+     */
+    getAllTags() {
+        return this.tags;
+    }
+    buildSpecification(spec = {}) {
+        const defaults = {
+            type: 3,
+            mime: 'image/jpeg',
+            description: '',
+            width: 0,
+            height: 0,
+            depth: 24,
+            colors: 0,
+        };
+        return Object.assign(defaults, spec);
+    }
+    /**
+     * Build a picture block.
+     *
+     * @param {Buffer} picture
+     * @param {Object} specification
+     * @returns {Buffer}
+     */
+    buildPictureBlock(picture, specification = {}) {
+        const pictureType = Buffer.alloc(4);
+        const mimeLength = Buffer.alloc(4);
+        const mime = Buffer.from(specification.mime, 'ascii');
+        const descriptionLength = Buffer.alloc(4);
+        const description = Buffer.from(specification.description, 'utf8');
+        const width = Buffer.alloc(4);
+        const height = Buffer.alloc(4);
+        const depth = Buffer.alloc(4);
+        const colors = Buffer.alloc(4);
+        const pictureLength = Buffer.alloc(4);
+        pictureType.writeUInt32BE(specification.type);
+        mimeLength.writeUInt32BE(specification.mime.length);
+        descriptionLength.writeUInt32BE(specification.description.length);
+        width.writeUInt32BE(specification.width);
+        height.writeUInt32BE(specification.height);
+        depth.writeUInt32BE(specification.depth);
+        colors.writeUInt32BE(specification.colors);
+        pictureLength.writeUInt32BE(picture.length);
+        return Buffer.concat([
+            pictureType,
+            mimeLength,
+            mime,
+            descriptionLength,
+            description,
+            width,
+            height,
+            depth,
+            colors,
+            pictureLength,
+            picture,
+        ]);
+    }
+    buildMetadataBlock(type, block, isLast = false) {
+        const header = Buffer.alloc(4);
+        if (isLast) {
+            type += 128;
+        }
+        header.writeUIntBE(type, 0, 1);
+        header.writeUIntBE(block.length, 1, 3);
+        return Buffer.concat([header, block]);
+    }
+    buildMetadata() {
+        const bufferArray = [];
+        bufferArray.push(this.buildMetadataBlock(STREAMINFO, this.streamInfo));
+        this.blocks.forEach((block) => {
+            // @ts-ignore
+            bufferArray.push(this.buildMetadataBlock(...block));
+        });
+        bufferArray.push(this.buildMetadataBlock(VORBIS_COMMENT, formatVorbisComment(this.vendorString, this.tags)));
+        this.pictures.forEach((block) => {
+            bufferArray.push(this.buildMetadataBlock(PICTURE, block));
+        });
+        if (this.padding == null) {
+            this.padding = Buffer.alloc(16384);
+        }
+        bufferArray.push(this.buildMetadataBlock(PADDING, this.padding, true));
+        return bufferArray;
+    }
+    buildStream() {
+        const metadata = this.buildMetadata();
+        return [this.buffer.slice(0, 4), ...metadata, this.buffer.slice(this.framesOffset)];
+    }
+    /**
+     * Save changes to buffer and return changed buffer
+     */
+    getBuffer() {
+        return Buffer.concat(this.buildStream());
+    }
+}
+exports.default = Metaflac;

package/dist/lib/request.d.ts

@@ -0,0 +1,18 @@
+import type { HttpQuery, HttpResponse } from './http';
+type DeezerRequestConfig = {
+    headers?: Record<string, string>;
+    params?: HttpQuery;
+};
+export declare const initDeezerApi: (arl: string) => Promise<string>;
+declare const _default: {
+    defaults: {
+        baseURL?: string | undefined;
+        headers: import("./http").HttpHeaders;
+        maxRedirects: number;
+        params: HttpQuery;
+        timeout: number;
+    };
+    get: <T>(url: string, config?: DeezerRequestConfig) => Promise<HttpResponse<T>>;
+    post: <T_1>(url: string, body?: unknown, config?: DeezerRequestConfig) => Promise<HttpResponse<T_1>>;
+};
+export default _default;

package/dist/lib/request.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initDeezerApi = void 0;
+const delay_1 = __importDefault(require("delay"));
+const http_1 = require("./http");
+let user_arl = 'c973964816688562722418b5200c1515dffaad15a42643ebf87cc72824a54612ec51c2ad42d566743f9e424c774e98ccae7737770acff59251328e6cd598c7bcac38ca269adf78bfb88ec5bbad6cd800db3c0b88b2af645bb22b99e71de26416';
+const instance = new http_1.HttpClient({
+    baseURL: 'https://api.deezer.com/1.0',
+    timeout: 15000,
+    headers: {
+        Accept: '*/*',
+        'Accept-Encoding': 'gzip, deflate',
+        'Accept-Language': 'en-US',
+        'Cache-Control': 'no-cache',
+        'Content-Type': 'application/json; charset=UTF-8',
+        'User-Agent': 'Deezer/8.32.0.2 (iOS; 14.4; Mobile; en; iPhone10_5)',
+    },
+    params: {
+        version: '8.32.0',
+        api_key: 'ZAIVAHCEISOHWAICUQUEXAEPICENGUAFAEZAIPHAELEEVAHPHUCUFONGUAPASUAY',
+        output: 3,
+        input: 3,
+        buildId: 'ios12_universal',
+        screenHeight: '480',
+        screenWidth: '320',
+        lang: 'en',
+    },
+});
+const getApiToken = async () => {
+    const { data } = await instance.get('https://www.deezer.com/ajax/gw-light.php', {
+        params: {
+            method: 'deezer.getUserData',
+            api_version: '1.0',
+            api_token: 'null',
+        },
+    });
+    instance.defaults.params.sid = data.results.SESSION_ID;
+    instance.defaults.params.api_token = data.results.checkForm;
+    return data.results.checkForm;
+};
+const initDeezerApi = async (arl) => {
+    if (arl.length !== 192) {
+        throw new Error(`Invalid arl. Length should be 192 characters. You have provided ${arl.length} characters.`);
+    }
+    user_arl = arl;
+    const { data } = await instance.get('https://www.deezer.com/ajax/gw-light.php', {
+        params: { method: 'deezer.ping', api_version: '1.0', api_token: '' },
+        headers: { cookie: 'arl=' + arl },
+    });
+    instance.defaults.params.sid = data.results.SESSION;
+    return data.results.SESSION;
+};
+exports.initDeezerApi = initDeezerApi;
+let token_retry = 0;
+const requestWithRetry = async (method, url, body, config = {}) => {
+    var _a;
+    const response = method === 'POST' ? await instance.post(url, body, config) : await instance.get(url, config);
+    const error = (_a = response.data) === null || _a === void 0 ? void 0 : _a.error;
+    if (!error || Object.keys(error).length === 0) {
+        token_retry = 0;
+        return response;
+    }
+    if (error.NEED_API_AUTH_REQUIRED) {
+        await (0, exports.initDeezerApi)(user_arl);
+        return await requestWithRetry(method, url, body, config);
+    }
+    if (error.code === 4) {
+        await delay_1.default.range(1000, 1500);
+        return await requestWithRetry(method, url, body, config);
+    }
+    if (error.GATEWAY_ERROR || (error.VALID_TOKEN_REQUIRED && token_retry < 15)) {
+        token_retry += 1;
+        await getApiToken();
+        return await requestWithRetry(method, url, body, config);
+    }
+    token_retry = 0;
+    return response;
+};
+exports.default = {
+    defaults: instance.defaults,
+    get: async (url, config = {}) => await requestWithRetry('GET', url, undefined, config),
+    post: async (url, body, config = {}) => await requestWithRetry('POST', url, body, config),
+};

package/dist/metadata-writer/abumCover.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import type { trackType } from '../types';
+type coverSize = 56 | 250 | 500 | 1000 | 1500 | 1800 | number;
+/**
+ *
+ * @param {Object} track track info json from deezer api
+ * @param {Number} albumCoverSize in pixel, between 56-1800
+ */
+export declare const downloadAlbumCover: (track: trackType, albumCoverSize: coverSize) => Promise<Buffer | null>;
+export {};

package/dist/metadata-writer/abumCover.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadAlbumCover = void 0;
+const fast_lru_1 = __importDefault(require("../lib/fast-lru"));
+const http_1 = require("../lib/http");
+// expire cache in 30 minutes
+const lru = new fast_lru_1.default({
+    maxSize: 50,
+    ttl: 30 * 60000,
+});
+/**
+ *
+ * @param {Object} track track info json from deezer api
+ * @param {Number} albumCoverSize in pixel, between 56-1800
+ */
+const downloadAlbumCover = async (track, albumCoverSize) => {
+    if (!track.ALB_PICTURE) {
+        return null;
+    }
+    const cache = lru.get(track.ALB_PICTURE + albumCoverSize);
+    if (cache) {
+        return cache;
+    }
+    try {
+        const url = `https://e-cdns-images.dzcdn.net/images/cover/${track.ALB_PICTURE}/${albumCoverSize}x${albumCoverSize}-000000-80-0-0.jpg`;
+        const data = await (0, http_1.getBuffer)(url);
+        lru.set(track.ALB_PICTURE + albumCoverSize, data);
+        return data;
+    }
+    catch (err) {
+        return null;
+    }
+};
+exports.downloadAlbumCover = downloadAlbumCover;

package/dist/metadata-writer/flacmetata.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import type { albumTypePublicApi, trackType } from '../types';
+export declare const writeMetadataFlac: (buffer: Buffer, track: trackType, album: albumTypePublicApi | null, dimension: number, cover?: Buffer | null) => Buffer;