hls-streamer 2.1.0 → 3.0.0

package/dist/cjs/Parsers/WavParser.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WavParser = void 0;
+class WavParser {
+    getFormat() {
+        return 'wav';
+    }
+    canParse(buffer) {
+        return buffer.length >= 12 &&
+            buffer.toString('ascii', 0, 4) === 'RIFF' &&
+            buffer.toString('ascii', 8, 12) === 'WAVE';
+    }
+    analyze(buffer, opts = {}) {
+        const warnings = [];
+        const size = opts.fileSize ?? buffer.length;
+        if (buffer.length < 44) {
+            return {
+                format: 'wav',
+                size,
+                duration: 0,
+                audioDataSize: 0,
+                frames: [],
+                warnings: ['File too small to be valid WAV']
+            };
+        }
+        if (!this.canParse(buffer)) {
+            return {
+                format: 'wav',
+                size,
+                duration: 0,
+                audioDataSize: 0,
+                frames: [],
+                warnings: ['Not a valid WAV file']
+            };
+        }
+        const riffSize = buffer.readUInt32LE(4);
+        let offset = 12;
+        let fmtData = null;
+        let dataOffset = -1;
+        let dataSize = 0;
+        while (offset + 8 <= buffer.length) {
+            const chunkId = buffer.toString('ascii', offset, offset + 4);
+            const chunkSize = buffer.readUInt32LE(offset + 4);
+            if (chunkId === 'fmt ') {
+                if (chunkSize < 16) {
+                    warnings.push('Invalid fmt chunk size');
+                    break;
+                }
+                fmtData = {
+                    audioFormat: buffer.readUInt16LE(offset + 8),
+                    channels: buffer.readUInt16LE(offset + 10),
+                    sampleRate: buffer.readUInt32LE(offset + 12),
+                    byteRate: buffer.readUInt32LE(offset + 16),
+                    blockAlign: buffer.readUInt16LE(offset + 20),
+                    bitsPerSample: buffer.readUInt16LE(offset + 22)
+                };
+            }
+            else if (chunkId === 'data') {
+                dataOffset = offset + 8;
+                dataSize = chunkSize;
+            }
+            offset += 8 + chunkSize;
+            if (chunkSize % 2 !== 0) {
+                offset++;
+            }
+        }
+        if (!fmtData) {
+            return {
+                format: 'wav',
+                size,
+                duration: 0,
+                audioDataSize: 0,
+                frames: [],
+                warnings: ['Missing fmt chunk']
+            };
+        }
+        if (dataOffset === -1) {
+            return {
+                format: 'wav',
+                size,
+                duration: 0,
+                audioDataSize: 0,
+                frames: [],
+                warnings: ['Missing data chunk']
+            };
+        }
+        if (fmtData.audioFormat !== 1) {
+            warnings.push(`Unsupported audio format: ${fmtData.audioFormat} (only PCM supported)`);
+        }
+        const bytesPerSample = fmtData.bitsPerSample / 8;
+        const totalSamples = dataSize / (bytesPerSample * fmtData.channels);
+        const duration = fmtData.sampleRate > 0 ? totalSamples / fmtData.sampleRate : 0;
+        const frames = [];
+        const samplesPerFrame = fmtData.sampleRate;
+        const bytesPerFrame = samplesPerFrame * bytesPerSample * fmtData.channels;
+        let frameOffset = dataOffset;
+        let frameIndex = 0;
+        let remainingBytes = dataSize;
+        while (remainingBytes > 0) {
+            const frameBytes = Math.min(bytesPerFrame, remainingBytes);
+            const frameSamples = frameBytes / (bytesPerSample * fmtData.channels);
+            const frameDuration = frameSamples / fmtData.sampleRate;
+            frames.push({
+                index: frameIndex,
+                offset: frameOffset,
+                length: frameBytes,
+                duration: frameDuration,
+                samples: Math.floor(frameSamples),
+                sampleRate: fmtData.sampleRate,
+                bitrate: Math.round((fmtData.byteRate * 8) / 1000)
+            });
+            frameOffset += frameBytes;
+            remainingBytes -= frameBytes;
+            frameIndex++;
+        }
+        const metadata = {
+            format: 'wav',
+            size,
+            duration,
+            audioDataSize: dataSize,
+            sampleRate: fmtData.sampleRate,
+            channels: fmtData.channels,
+            bitDepth: fmtData.bitsPerSample,
+            averageBitrate: Math.round((fmtData.byteRate * 8) / 1000),
+            frames
+        };
+        if (warnings.length > 0) {
+            metadata.warnings = warnings;
+        }
+        metadata.metadata = {
+            audioFormat: fmtData.audioFormat,
+            blockAlign: fmtData.blockAlign,
+            riffSize
+        };
+        return metadata;
+    }
+}
+exports.WavParser = WavParser;
+//# sourceMappingURL=WavParser.js.map

package/dist/cjs/Parsers/WavParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WavParser.js","sourceRoot":"","sources":["../../../src/Parsers/WavParser.ts"],"names":[],"mappings":"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"}

package/dist/cjs/errors/HlsStreamerErrors.d.ts

@@ -13,4 +13,7 @@ export declare class InvalidRangeError extends HlsStreamerError {
 export declare class InvalidParameterError extends HlsStreamerError {
     constructor(parameter: string, value: any);
 }
+export declare class UnsupportedFormatError extends HlsStreamerError {
+    constructor(format: string);
+}
 //# sourceMappingURL=HlsStreamerErrors.d.ts.map

package/dist/cjs/errors/HlsStreamerErrors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HlsStreamerErrors.d.ts","sourceRoot":"","sources":["../../../src/errors/HlsStreamerErrors.ts"],"names":[],"mappings":"AAGA,qBAAa,gBAAiB,SAAQ,KAAK;gBAC7B,OAAO,EAAE,MAAM;CAI5B;AAKD,qBAAa,iBAAkB,SAAQ,gBAAgB;gBACzC,QAAQ,EAAE,MAAM;CAI7B;AAKD,qBAAa,gBAAiB,SAAQ,gBAAgB;gBACxC,OAAO,EAAE,MAAM;CAI5B;AAKD,qBAAa,iBAAkB,SAAQ,gBAAgB;gBACzC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAI/C;AAKD,qBAAa,qBAAsB,SAAQ,gBAAgB;gBAC7C,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG;CAI1C"}
+{"version":3,"file":"HlsStreamerErrors.d.ts","sourceRoot":"","sources":["../../../src/errors/HlsStreamerErrors.ts"],"names":[],"mappings":"AAGA,qBAAa,gBAAiB,SAAQ,KAAK;gBAC7B,OAAO,EAAE,MAAM;CAI5B;AAKD,qBAAa,iBAAkB,SAAQ,gBAAgB;gBACzC,QAAQ,EAAE,MAAM;CAI7B;AAKD,qBAAa,gBAAiB,SAAQ,gBAAgB;gBACxC,OAAO,EAAE,MAAM;CAI5B;AAKD,qBAAa,iBAAkB,SAAQ,gBAAgB;gBACzC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAI/C;AAKD,qBAAa,qBAAsB,SAAQ,gBAAgB;gBAC7C,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG;CAI1C;AAKD,qBAAa,sBAAuB,SAAQ,gBAAgB;gBAC9C,MAAM,EAAE,MAAM;CAI3B"}

package/dist/cjs/errors/HlsStreamerErrors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidParameterError = exports.InvalidRangeError = exports.InvalidFileError = exports.FileNotFoundError = exports.HlsStreamerError = void 0;
+exports.UnsupportedFormatError = exports.InvalidParameterError = exports.InvalidRangeError = exports.InvalidFileError = exports.FileNotFoundError = exports.HlsStreamerError = void 0;
 class HlsStreamerError extends Error {
     constructor(message) {
         super(message);
@@ -36,4 +36,11 @@ class InvalidParameterError extends HlsStreamerError {
     }
 }
 exports.InvalidParameterError = InvalidParameterError;
+class UnsupportedFormatError extends HlsStreamerError {
+    constructor(format) {
+        super(`Unsupported audio format: ${format}`);
+        this.name = 'UnsupportedFormatError';
+    }
+}
+exports.UnsupportedFormatError = UnsupportedFormatError;
 //# sourceMappingURL=HlsStreamerErrors.js.map

package/dist/cjs/errors/HlsStreamerErrors.js.map

@@ -1 +1 @@
-{"version":3,"file":"HlsStreamerErrors.js","sourceRoot":"","sources":["../../../src/errors/HlsStreamerErrors.ts"],"names":[],"mappings":";;;AAGA,MAAa,gBAAiB,SAAQ,KAAK;IACzC,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IACjC,CAAC;CACF;AALD,4CAKC;AAKD,MAAa,iBAAkB,SAAQ,gBAAgB;IACrD,YAAY,QAAgB;QAC1B,KAAK,CAAC,mBAAmB,QAAQ,EAAE,CAAC,CAAC;QACrC,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;IAClC,CAAC;CACF;AALD,8CAKC;AAKD,MAAa,gBAAiB,SAAQ,gBAAgB;IACpD,YAAY,OAAe;QACzB,KAAK,CAAC,iBAAiB,OAAO,EAAE,CAAC,CAAC;QAClC,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IACjC,CAAC;CACF;AALD,4CAKC;AAKD,MAAa,iBAAkB,SAAQ,gBAAgB;IACrD,YAAY,SAAiB,EAAE,OAAe;QAC5C,KAAK,CAAC,wBAAwB,SAAS,SAAS,OAAO,EAAE,CAAC,CAAC;QAC3D,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;IAClC,CAAC;CACF;AALD,8CAKC;AAKD,MAAa,qBAAsB,SAAQ,gBAAgB;IACzD,YAAY,SAAiB,EAAE,KAAU;QACvC,KAAK,CAAC,sBAAsB,SAAS,MAAM,KAAK,EAAE,CAAC,CAAC;QACpD,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;IACtC,CAAC;CACF;AALD,sDAKC"}
+{"version":3,"file":"HlsStreamerErrors.js","sourceRoot":"","sources":["../../../src/errors/HlsStreamerErrors.ts"],"names":[],"mappings":";;;AAGA,MAAa,gBAAiB,SAAQ,KAAK;IACzC,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IACjC,CAAC;CACF;AALD,4CAKC;AAKD,MAAa,iBAAkB,SAAQ,gBAAgB;IACrD,YAAY,QAAgB;QAC1B,KAAK,CAAC,mBAAmB,QAAQ,EAAE,CAAC,CAAC;QACrC,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;IAClC,CAAC;CACF;AALD,8CAKC;AAKD,MAAa,gBAAiB,SAAQ,gBAAgB;IACpD,YAAY,OAAe;QACzB,KAAK,CAAC,iBAAiB,OAAO,EAAE,CAAC,CAAC;QAClC,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IACjC,CAAC;CACF;AALD,4CAKC;AAKD,MAAa,iBAAkB,SAAQ,gBAAgB;IACrD,YAAY,SAAiB,EAAE,OAAe;QAC5C,KAAK,CAAC,wBAAwB,SAAS,SAAS,OAAO,EAAE,CAAC,CAAC;QAC3D,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;IAClC,CAAC;CACF;AALD,8CAKC;AAKD,MAAa,qBAAsB,SAAQ,gBAAgB;IACzD,YAAY,SAAiB,EAAE,KAAU;QACvC,KAAK,CAAC,sBAAsB,SAAS,MAAM,KAAK,EAAE,CAAC,CAAC;QACpD,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;IACtC,CAAC;CACF;AALD,sDAKC;AAKD,MAAa,sBAAuB,SAAQ,gBAAgB;IAC1D,YAAY,MAAc;QACxB,KAAK,CAAC,6BAA6B,MAAM,EAAE,CAAC,CAAC;QAC7C,IAAI,CAAC,IAAI,GAAG,wBAAwB,CAAC;IACvC,CAAC;CACF;AALD,wDAKC"}

package/dist/cjs/index.d.ts

@@ -5,23 +5,22 @@ export declare class HlsStreamer {
     private readonly fileName;
     private readonly baseUrl;
     private readonly enableFastStart;
+    private readonly formatOverride;
     private fileInfo?;
-    private segmentCache;
-    private frameAlignedSegments;
+    private segments;
     constructor(options: HlsStreamerOptions);
     private validateOptions;
     private validateFile;
     private getFileInfo;
     getFileBuffer(startByte: number, endByte: number): Promise<Buffer>;
     createM3U8(): Promise<string>;
-    private calculateSegmentCount;
+    private getSegments;
+    private computeTargetSizes;
+    private computeTargetSizesFromBytes;
+    private buildSegmentsWithoutFrameTable;
     private estimateSegmentDuration;
     private buildSegmentUrl;
     private calculateSegmentSize;
-    private calculateSegment;
-    private getFrameAlignedSegment;
-    private findNextMp3Frame;
-    private calculatefirst2SegmentSize;
     private padNumber;
     getSegmentDuration(segmentIndex: number): Promise<number>;
 }

package/dist/cjs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAA4B,MAAM,0BAA0B,CAAC;AAYxF,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAU;IAC1C,OAAO,CAAC,QAAQ,CAAC,CAAc;IAC/B,OAAO,CAAC,YAAY,CAAkC;IACtD,OAAO,CAAC,oBAAoB,CAAqD;gBAKrE,OAAO,EAAE,kBAAkB;IAWvC,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,YAAY;YAgBN,WAAW;IA2BnB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAmDlE,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IA6BnC,OAAO,CAAC,qBAAqB;IAW7B,OAAO,CAAC,uBAAuB;IAO/B,OAAO,CAAC,eAAe;IAKvB,OAAO,CAAC,oBAAoB;IAe5B,OAAO,CAAC,gBAAgB;YAuBV,sBAAsB;IA+BpC,OAAO,CAAC,gBAAgB;IAwCxB,OAAO,CAAC,0BAA0B;IAIlC,OAAO,CAAC,SAAS;IAOX,kBAAkB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAoBhE;AAGD,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAA8B,MAAM,0BAA0B,CAAC;AAe1F,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAU;IAC1C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqB;IACpD,OAAO,CAAC,QAAQ,CAAC,CAAgB;IACjC,OAAO,CAAC,QAAQ,CAA4B;gBAKhC,OAAO,EAAE,kBAAkB;IAYvC,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,YAAY;YAyBN,WAAW;IAkBnB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA4BlE,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;YA+BrB,WAAW;IAiFzB,OAAO,CAAC,kBAAkB;IAK1B,OAAO,CAAC,2BAA2B;IAmBnC,OAAO,CAAC,8BAA8B;IA0BtC,OAAO,CAAC,uBAAuB;IAe/B,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,oBAAoB;IAgB5B,OAAO,CAAC,SAAS;IAOX,kBAAkB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAchE;AAGD,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC"}

package/dist/cjs/index.js

@@ -21,6 +21,7 @@ exports.HlsStreamer = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const FileLib_1 = require("./Libs/FileLib");
+const FormatDetector_1 = require("./Libs/FormatDetector");
 const HlsStreamerErrors_1 = require("./errors/HlsStreamerErrors");
 class HlsStreamer {
     constructor(options) {
@@ -54,31 +55,32 @@ class HlsStreamer {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "fileInfo", {
+        Object.defineProperty(this, "formatOverride", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "segmentCache", {
+        Object.defineProperty(this, "fileInfo", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Map()
+            value: void 0
         });
-        Object.defineProperty(this, "frameAlignedSegments", {
+        Object.defineProperty(this, "segments", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Map()
+            value: void 0
         });
         this.validateOptions(options);
-        this.validateFile(options.filePath);
+        this.validateFile(options.filePath, options.format);
         this.filePath = options.filePath;
         this.segmentSize = (options.segmentSizeKB ?? 512) * 1024;
         this.fileName = options.fileName ?? "file";
         this.baseUrl = options.baseUrl ?? "";
         this.enableFastStart = options.enableFastStart ?? false;
+        this.formatOverride = options.format || undefined;
     }
     validateOptions(options) {
         if (!options.filePath || typeof options.filePath !== 'string') {
@@ -92,7 +94,7 @@ class HlsStreamer {
             throw new HlsStreamerErrors_1.InvalidParameterError('fileName', options.fileName);
         }
     }
-    validateFile(filePath) {
+    validateFile(filePath, format) {
         if (!node_fs_1.default.existsSync(filePath)) {
             throw new HlsStreamerErrors_1.FileNotFoundError(filePath);
         }
@@ -100,25 +102,27 @@ class HlsStreamer {
         if (!stat.isFile()) {
             throw new HlsStreamerErrors_1.InvalidFileError('Path is not a file');
         }
-        const ext = node_path_1.default.extname(filePath).toLowerCase();
-        if (ext !== '.mp3') {
-            throw new HlsStreamerErrors_1.InvalidFileError('Only MP3 files are supported');
+        if (format) {
+            const supportedFormats = ['mp3', 'aac', 'm4a', 'ogg', 'flac', 'wav'];
+            if (!supportedFormats.includes(format.toLowerCase())) {
+                throw new HlsStreamerErrors_1.UnsupportedFormatError(format);
+            }
+        }
+        else {
+            if (!FormatDetector_1.FormatDetector.isSupportedExtension(filePath)) {
+                const ext = node_path_1.default.extname(filePath);
+                throw new HlsStreamerErrors_1.UnsupportedFormatError(ext || 'unknown');
+            }
         }
     }
     async getFileInfo() {
         if (!this.fileInfo) {
-            const stat = await node_fs_1.default.promises.stat(this.filePath);
-            const size = stat.size;
-            if (size <= 0) {
+            const analysis = await FileLib_1.FileLib.analyzeAudioFile(this.filePath, this.formatOverride);
+            if (analysis.size <= 0) {
                 throw new HlsStreamerErrors_1.InvalidFileError('File is empty');
             }
-            if (this.segmentSize > size) {
-                throw new HlsStreamerErrors_1.InvalidFileError('Segment size is larger than file size');
-            }
-            this.fileInfo = {
-                size,
-                duration: 0
-            };
+            this.fileInfo = analysis;
+            this.segments = undefined;
         }
         return this.fileInfo;
     }
@@ -130,26 +134,14 @@ class HlsStreamer {
         if (endByte > fileInfo.size) {
             throw new HlsStreamerErrors_1.InvalidRangeError(startByte, endByte);
         }
-        const searchBufferSize = Math.min(8192, fileInfo.size);
-        const searchStartByte = Math.max(0, startByte - 1024);
-        const searchEndByte = Math.min(fileInfo.size, startByte + searchBufferSize);
+        const length = endByte - startByte;
         const fd = node_fs_1.default.openSync(this.filePath, "r");
         try {
-            const searchBuffer = Buffer.alloc(searchEndByte - searchStartByte);
-            node_fs_1.default.readSync(fd, searchBuffer, 0, searchBuffer.length, searchStartByte);
-            const targetOffsetInSearch = startByte - searchStartByte;
-            const frameAlignedOffsetInSearch = this.findNextMp3Frame(searchBuffer, Math.max(0, targetOffsetInSearch));
-            const actualStartByte = searchStartByte + frameAlignedOffsetInSearch;
-            const actualEndByte = Math.min(endByte, fileInfo.size);
-            const bufferLength = actualEndByte - actualStartByte;
-            if (bufferLength <= 0) {
-                const fallbackLength = endByte - startByte;
-                const fallbackBuffer = Buffer.alloc(fallbackLength);
-                const bytesRead = node_fs_1.default.readSync(fd, fallbackBuffer, 0, fallbackLength, startByte);
-                return fallbackBuffer.subarray(0, bytesRead);
+            if (length === 0) {
+                return Buffer.alloc(0);
             }
-            const buffer = Buffer.alloc(bufferLength);
-            const bytesRead = node_fs_1.default.readSync(fd, buffer, 0, bufferLength, actualStartByte);
+            const buffer = Buffer.alloc(length);
+            const bytesRead = node_fs_1.default.readSync(fd, buffer, 0, length, startByte);
             return buffer.subarray(0, bytesRead);
         }
         finally {
@@ -157,40 +149,146 @@ class HlsStreamer {
         }
     }
     async createM3U8() {
-        const fileInfo = await this.getFileInfo();
-        const segmentCount = this.calculateSegmentCount(fileInfo.size);
+        const [fileInfo, segments] = await Promise.all([
+            this.getFileInfo(),
+            this.getSegments()
+        ]);
+        if (!segments.length) {
+            throw new HlsStreamerErrors_1.InvalidFileError('Unable to generate segments for MP3 file');
+        }
+        const maxSegmentDuration = segments.reduce((max, segment) => Math.max(max, segment.duration), 0);
+        const targetDurationSeconds = Math.max(1, Math.ceil(maxSegmentDuration || fileInfo.duration || 1));
         const m3u8 = [
             '#EXTM3U',
             '#EXT-X-VERSION:6',
             '#EXT-X-PLAYLIST-TYPE:VOD',
-            '#EXT-X-TARGETDURATION:14',
+            `#EXT-X-TARGETDURATION:${targetDurationSeconds}`,
             '#EXT-X-MEDIA-SEQUENCE:0',
         ];
-        for (let i = 0; i < segmentCount; i++) {
-            const { start, end } = await this.getFrameAlignedSegment(i, fileInfo.size);
-            const estimatedDuration = this.estimateSegmentDuration(end - start);
-            const segmentUrl = this.buildSegmentUrl(start, end, i);
-            m3u8.push(`#EXTINF:${estimatedDuration.toFixed(3)}`);
+        segments.forEach((segment, index) => {
+            const segmentUrl = this.buildSegmentUrl(segment.start, segment.end, index);
+            m3u8.push(`#EXTINF:${segment.duration.toFixed(3)}`);
             m3u8.push(segmentUrl);
-        }
+        });
         m3u8.push('#EXT-X-ENDLIST');
         return m3u8.join('\n');
     }
-    calculateSegmentCount(fileSize) {
-        if (!this.enableFastStart) {
-            return Math.ceil(fileSize / this.segmentSize);
+    async getSegments() {
+        if (this.segments) {
+            return this.segments;
+        }
+        const fileInfo = await this.getFileInfo();
+        if (!fileInfo.frames.length) {
+            this.segments = this.buildSegmentsWithoutFrameTable(fileInfo);
+            return this.segments;
+        }
+        const targetSizes = this.computeTargetSizes(fileInfo);
+        const segments = [];
+        const frames = fileInfo.frames;
+        let frameCursor = 0;
+        const consumeFrames = (targetBytes) => {
+            if (frameCursor >= frames.length) {
+                return;
+            }
+            const startFrameIndex = frameCursor;
+            let consumedBytes = 0;
+            let duration = 0;
+            while (frameCursor < frames.length) {
+                const frame = frames[frameCursor];
+                const nextBytes = consumedBytes + frame.length;
+                if (consumedBytes > 0 && nextBytes > targetBytes) {
+                    break;
+                }
+                consumedBytes = nextBytes;
+                duration += frame.duration;
+                frameCursor++;
+                if (consumedBytes >= targetBytes) {
+                    break;
+                }
+            }
+            if (frameCursor === startFrameIndex && frameCursor < frames.length) {
+                const frame = frames[frameCursor];
+                consumedBytes += frame.length;
+                duration += frame.duration;
+                frameCursor++;
+            }
+            if (frameCursor === startFrameIndex) {
+                return;
+            }
+            const start = frames[startFrameIndex].offset;
+            const lastFrame = frames[frameCursor - 1];
+            const end = lastFrame.offset + lastFrame.length;
+            segments.push({
+                start,
+                end,
+                duration
+            });
+        };
+        targetSizes.forEach(consumeFrames);
+        while (frameCursor < frames.length) {
+            consumeFrames(this.segmentSize);
+        }
+        if (!segments.length) {
+            this.segments = this.buildSegmentsWithoutFrameTable(fileInfo);
+        }
+        else {
+            this.segments = segments;
+        }
+        return this.segments;
+    }
+    computeTargetSizes(fileInfo) {
+        const totalBytes = fileInfo.audioDataSize || fileInfo.size;
+        return this.computeTargetSizesFromBytes(totalBytes);
+    }
+    computeTargetSizesFromBytes(totalBytes) {
+        if (totalBytes <= 0) {
+            return [];
+        }
+        const targets = [];
+        let remaining = totalBytes;
+        let index = 0;
+        while (remaining > 0) {
+            const targetSize = Math.min(this.calculateSegmentSize(index), remaining);
+            targets.push(targetSize);
+            remaining -= targetSize;
+            index++;
+        }
+        return targets.length ? targets : [totalBytes];
+    }
+    buildSegmentsWithoutFrameTable(fileInfo) {
+        const segments = [];
+        const totalBytes = Math.max(fileInfo.size, fileInfo.audioDataSize);
+        if (totalBytes <= 0) {
+            return segments;
+        }
+        const targets = this.computeTargetSizesFromBytes(totalBytes);
+        let start = 0;
+        targets.forEach((targetSize) => {
+            const end = Math.min(totalBytes, start + targetSize);
+            const duration = this.estimateSegmentDuration(end - start, fileInfo);
+            segments.push({ start, end, duration });
+            start = end;
+        });
+        if (start < totalBytes) {
+            const duration = this.estimateSegmentDuration(totalBytes - start, fileInfo);
+            segments.push({ start, end: totalBytes, duration });
         }
-        const firstTwoSegmentsSize = this.calculatefirst2SegmentSize();
-        const remainingSize = fileSize - firstTwoSegmentsSize;
-        return Math.ceil(remainingSize / this.segmentSize) + 2;
+        return segments;
     }
-    estimateSegmentDuration(segmentSize) {
-        const estimatedBytesPerSecond = 16000;
+    estimateSegmentDuration(segmentSize, fileInfo) {
+        if (fileInfo.duration > 0 && fileInfo.audioDataSize > 0) {
+            const bytesPerSecond = fileInfo.audioDataSize / fileInfo.duration;
+            return segmentSize / bytesPerSecond;
+        }
+        const estimatedBytesPerSecond = fileInfo.averageBitrate
+            ? (fileInfo.averageBitrate * 1000) / 8
+            : 16000;
         return segmentSize / estimatedBytesPerSecond;
     }
     buildSegmentUrl(start, end, index) {
         const baseUrlPrefix = this.baseUrl ? `/${this.baseUrl}` : '';
-        return `${baseUrlPrefix}/${start}/${end}/${this.fileName}${this.padNumber(index, 3)}.mp3`;
+        const ext = this.fileInfo?.format || node_path_1.default.extname(this.filePath).toLowerCase().slice(1) || 'mp3';
+        return `${baseUrlPrefix}/${start}/${end}/${this.fileName}${this.padNumber(index, 3)}.${ext}`;
     }
     calculateSegmentSize(segmentIndex) {
         if (!this.enableFastStart) {
@@ -205,94 +303,19 @@ class HlsStreamer {
                 return this.segmentSize;
         }
     }
-    calculateSegment(segmentIndex, fileSize) {
-        let start = 0;
-        if (this.enableFastStart && segmentIndex < 2) {
-            start = segmentIndex * (this.segmentSize / 4);
-        }
-        else if (this.enableFastStart) {
-            start = (3 * this.segmentSize) / 4 + (segmentIndex - 2) * this.segmentSize;
-        }
-        else {
-            start = segmentIndex * this.segmentSize;
-        }
-        const segmentSize = this.calculateSegmentSize(segmentIndex);
-        const end = Math.min(start + segmentSize, fileSize);
-        return { start: Math.floor(start), end: Math.floor(end) };
-    }
-    async getFrameAlignedSegment(segmentIndex, fileSize) {
-        if (this.frameAlignedSegments.has(segmentIndex)) {
-            return this.frameAlignedSegments.get(segmentIndex);
-        }
-        const rawSegment = this.calculateSegment(segmentIndex, fileSize);
-        if (segmentIndex === 0) {
-            const fd = node_fs_1.default.openSync(this.filePath, "r");
-            try {
-                const headerBuffer = Buffer.alloc(Math.min(8192, fileSize));
-                node_fs_1.default.readSync(fd, headerBuffer, 0, headerBuffer.length, 0);
-                const frameStart = this.findNextMp3Frame(headerBuffer, 0);
-                const alignedSegment = { start: frameStart, end: rawSegment.end };
-                this.frameAlignedSegments.set(segmentIndex, alignedSegment);
-                return alignedSegment;
-            }
-            finally {
-                node_fs_1.default.closeSync(fd);
-            }
-        }
-        this.frameAlignedSegments.set(segmentIndex, rawSegment);
-        return rawSegment;
-    }
-    findNextMp3Frame(buffer, startPos) {
-        let pos = startPos;
-        if (pos === 0 && buffer.length > 10 && buffer.toString('ascii', 0, 3) === 'ID3') {
-            const tagSize = ((buffer[6] & 0x7f) << 21) |
-                ((buffer[7] & 0x7f) << 14) |
-                ((buffer[8] & 0x7f) << 7) |
-                (buffer[9] & 0x7f);
-            pos = 10 + tagSize;
-        }
-        while (pos < buffer.length - 1) {
-            if (buffer[pos] === 0xFF && (buffer[pos + 1] & 0xE0) === 0xE0) {
-                if (pos + 3 < buffer.length) {
-                    const header = (buffer[pos] << 24) |
-                        (buffer[pos + 1] << 16) |
-                        (buffer[pos + 2] << 8) |
-                        buffer[pos + 3];
-                    const version = (header >> 19) & 0x3;
-                    const layer = (header >> 17) & 0x3;
-                    const bitrateIndex = (header >> 12) & 0xF;
-                    const sampleRateIndex = (header >> 10) & 0x3;
-                    if (version !== 1 && layer !== 0 && bitrateIndex !== 0 &&
-                        bitrateIndex !== 15 && sampleRateIndex !== 3) {
-                        return pos;
-                    }
-                }
-            }
-            pos++;
-        }
-        return startPos;
-    }
-    calculatefirst2SegmentSize() {
-        return (this.segmentSize / 4) * 3;
-    }
     padNumber(value, padding) {
         return value.toString().padStart(padding, '0');
     }
     async getSegmentDuration(segmentIndex) {
-        const cachedSegment = this.segmentCache.get(segmentIndex);
-        if (cachedSegment) {
-            return cachedSegment.duration;
+        if (!Number.isInteger(segmentIndex) || segmentIndex < 0) {
+            throw new HlsStreamerErrors_1.InvalidParameterError('segmentIndex', segmentIndex);
         }
-        const fileInfo = await this.getFileInfo();
-        const { start, end } = this.calculateSegment(segmentIndex, fileInfo.size);
-        const segmentBuffer = await this.getFileBuffer(start, end);
-        const duration = await FileLib_1.FileLib.getMP3DurationFromBuffer(segmentBuffer);
-        this.segmentCache.set(segmentIndex, {
-            start,
-            end,
-            duration
-        });
-        return duration;
+        const segments = await this.getSegments();
+        const segment = segments[segmentIndex];
+        if (!segment) {
+            throw new HlsStreamerErrors_1.InvalidParameterError('segmentIndex', segmentIndex);
+        }
+        return segment.duration;
     }
 }
 exports.HlsStreamer = HlsStreamer;