node-id3/src/ID3Util.js

const iconv = require('iconv-lite')
const ID3Definitions = require('./ID3Definitions')

const ENCODINGS = [
    'ISO-8859-1', 'UTF-16', 'UTF-16BE', 'UTF-8'
]

module.exports.SplitBuffer = class SplitBuffer {
    constructor(value = null, remainder = null) {
        this.value = value
        this.remainder = remainder
    }
}

module.exports.splitNullTerminatedBuffer = function(buffer, encodingByte = 0x00) {
    let termination = { start: -1, size: 0 }
    if(encodingByte === 0x01 || encodingByte === 0x02) {
        termination.start = buffer.indexOf(Buffer.from([0x00, 0x00]))
        termination.size = 2
        if(termination.start !== -1 && buffer.length > (termination.start + termination.size)) {
            if(buffer[termination.start + termination.size] === 0x00) {
                termination.start += 1
            }
        }
    } else {
        termination.start = buffer.indexOf(0x00)
        termination.size = 1
    }

    if(termination.start === -1) {
        return new this.SplitBuffer(null, buffer.slice(0))
    }
    else if(buffer.length <= termination.start + termination.length) {
        return new this.SplitBuffer(buffer.slice(0, termination.start), null)
    } else {
        return new this.SplitBuffer(buffer.slice(0, termination.start), buffer.slice(termination.start + termination.size))
    }
}

module.exports.terminationBuffer = function(encodingByte = 0x00) {
    if(encodingByte === 0x01 || encodingByte === 0x02) {
        return Buffer.alloc(2, 0x00)
    } else {
        return Buffer.alloc(1, 0x00)
    }
}

module.exports.encodingFromStringOrByte = function(encoding) {
    if(ENCODINGS.indexOf(encoding) !== -1) {
        return encoding
    } else if(encoding > -1 && encoding < ENCODINGS.length) {
        encoding = ENCODINGS[encoding]
    } else {
        encoding = ENCODINGS[0]
    }
    return encoding
}

module.exports.stringToEncodedBuffer = function(str, encodingByte) {
    return iconv.encode(str, this.encodingFromStringOrByte(encodingByte))
}

module.exports.bufferToDecodedString = function(buffer, encodingByte) {
    return iconv.decode(buffer, this.encodingFromStringOrByte(encodingByte)).replace(/\0/g, '')
}

module.exports.getSpecOptions = function(specName, version) {
    if(version === 2) {
        if(ID3Definitions.ID3_FRAME_OPTIONS.v2[specName] && ID3Definitions.ID3_FRAME_OPTIONS.v2[specName]) {
            return ID3Definitions.ID3_FRAME_OPTIONS.v2[specName]
        }
    } else if (version === 3 || version === 4) {
        if(ID3Definitions.ID3_FRAME_OPTIONS.v3[specName] && ID3Definitions.ID3_FRAME_OPTIONS.v3[specName]) {
            return ID3Definitions.ID3_FRAME_OPTIONS.v3[specName]
        }
    }
    return {}
}

module.exports.isValidID3Header = function(buffer) {
    if(buffer.length < 10) {
        return false;
    } else if(buffer.readUIntBE(0, 3) !== 0x494433) {
        return false;
    } else if([0x02, 0x03, 0x04].indexOf(buffer[3]) === -1 || buffer[4] !== 0x00) {
        return false;
    } else if(buffer[6] & 128 === 1 || buffer[7] & 128 === 1 || buffer[8] & 128 === 1 || buffer[9] & 128 === 1) {
        return false;
    }
    return true;
};

module.exports.getFramePosition = function(buffer) {
    /* Search Buffer for valid ID3 frame */
    let framePosition = -1;
    let frameHeaderValid = false;
    do {
        framePosition = buffer.indexOf("ID3", framePosition + 1);
        if(framePosition !== -1) {
            /* It's possible that there is a "ID3" sequence without being an ID3 Frame,
             * so we need to check for validity of the next 10 bytes
             */
            frameHeaderValid = this.isValidID3Header(buffer.slice(framePosition, framePosition + 10));
        }
    } while (framePosition !== -1 && !frameHeaderValid);

    if(!frameHeaderValid) {
        return -1;
    } else {
        return framePosition;
    }
}

/**
 * @return {Buffer}
 */
module.exports.encodeSize = function(totalSize) {
    let byte_3 = totalSize & 0x7F;
    let byte_2 = (totalSize >> 7) & 0x7F;
    let byte_1 = (totalSize >> 14) & 0x7F;
    let byte_0 = (totalSize >> 21) & 0x7F;
    return Buffer.from([byte_0, byte_1, byte_2, byte_3]);
};

/**
 * @return {Buffer}
 */
module.exports.decodeSize = function(hSize) {
    return (hSize[0] << 21) + (hSize[1] << 14) + (hSize[2] << 7) + hSize[3];
};

module.exports.getFrameSize = function(buffer, decode, ID3Version) {
    let decodeBytes
    if(ID3Version > 2) {
        decodeBytes = [buffer[4], buffer[5], buffer[6], buffer[7]]
    } else {
        decodeBytes = [buffer[3], buffer[4], buffer[5]]
    }
    if(decode) {
        return this.decodeSize(Buffer.from(decodeBytes))
    } else {
        return Buffer.from(decodeBytes).readUIntBE(0, decodeBytes.length)
    }
}

module.exports.parseTagHeaderFlags = function(header) {
    if(!(header instanceof Buffer && header.length >= 10)) {
        return {}
    }
    const version = header[3]
    const flagsByte = header[5]
    if(version === 3) {
        return {
            unsynchronisation: !!(flagsByte & 128),
            extendedHeader: !!(flagsByte & 64),
            experimentalIndicator: !!(flagsByte & 32)
        }
    }
    if(version === 4) {
        return {
            unsynchronisation: !!(flagsByte & 128),
            extendedHeader: !!(flagsByte & 64),
            experimentalIndicator: !!(flagsByte & 32),
            footerPresent: !!(flagsByte & 16)
        }
    }
    return {}
}

module.exports.parseFrameHeaderFlags = function(header, ID3Version) {
    if(!(header instanceof Buffer && header.length === 10)) {
        return {}
    }
    const flagsFirstByte = header[8]
    const flagsSecondByte = header[9]
    if(ID3Version === 3) {
        return {
            tagAlterPreservation: !!(flagsFirstByte & 128),
            fileAlterPreservation: !!(flagsFirstByte & 64),
            readOnly: !!(flagsFirstByte & 32),
            compression: !!(flagsSecondByte & 128),
            encryption: !!(flagsSecondByte & 64),
            groupingIdentity: !!(flagsSecondByte & 32)
        }
    }
    if(ID3Version === 4) {
        return {
            tagAlterPreservation: !!(flagsFirstByte & 64),
            fileAlterPreservation: !!(flagsFirstByte & 32),
            readOnly: !!(flagsFirstByte & 16),
            groupingIdentity: !!(flagsSecondByte & 64),
            compression: !!(flagsSecondByte & 8),
            encryption: !!(flagsSecondByte & 4),
            unsynchronisation: !!(flagsSecondByte & 2),
            dataLengthIndicator: !!(flagsSecondByte & 1)
        }
    }
    return {}
}

module.exports.processUnsynchronisedBuffer = function(buffer) {
    const bufStr = buffer.toString('hex')
    return Buffer.from(bufStr.replace(/ff00/g, 'ff'), 'hex')
}