Quantumbraid's picture
download
raw
7.2 kB
/* eslint-disable */
import { NextRequest, NextResponse } from 'next/server';
import fs from 'fs';
import path from 'path';
import { getDatasetsRoot, getTrainingFolder, getDataRoot } from '@/server/settings';
import { catchAllToFilePath } from '@/server/catchAllPath';
/**
* Serves embedded album art from an MP3 file's ID3v2 tag.
* Reads only the tag header from disk (no full-file buffering).
* Returns the raw image bytes with correct Content-Type.
*/
function synchsafeToInt(b0: number, b1: number, b2: number, b3: number) {
return ((b0 & 0x7f) << 21) | ((b1 & 0x7f) << 14) | ((b2 & 0x7f) << 7) | (b3 & 0x7f);
}
function deUnsync(bytes: Buffer) {
const out: number[] = [];
for (let i = 0; i < bytes.length; i++) {
out.push(bytes[i]);
if (bytes[i] === 0xff && i + 1 < bytes.length && bytes[i + 1] === 0x00) i += 1;
}
return Buffer.from(out);
}
function readNullTerminated(buf: Buffer, start: number, wide: boolean): { text: string; next: number } {
if (wide) {
let i = start;
while (i + 1 < buf.length && !(buf[i] === 0 && buf[i + 1] === 0)) i += 2;
return { text: buf.slice(start, i).toString('utf16le'), next: i + 2 };
}
let i = start;
while (i < buf.length && buf[i] !== 0) i++;
return { text: buf.slice(start, i).toString('latin1'), next: i + 1 };
}
type ArtResult = { mime: string; data: Buffer } | null;
function extractArtFromTag(buf: Buffer): ArtResult {
if (buf.length < 10) return null;
if (buf[0] !== 0x49 || buf[1] !== 0x44 || buf[2] !== 0x33) return null; // "ID3"
const verMajor = buf[3]; // 2, 3, or 4
const flags = buf[5];
const tagSize = synchsafeToInt(buf[6], buf[7], buf[8], buf[9]);
const tagEnd = Math.min(10 + tagSize, buf.length);
let tagData = buf.slice(10, tagEnd);
if ((flags & 0x80) !== 0) tagData = deUnsync(tagData);
let offset = 0;
// Skip extended header
if ((verMajor === 3 || verMajor === 4) && (flags & 0x40) !== 0 && tagData.length >= 4) {
const extSize =
verMajor === 4
? synchsafeToInt(tagData[0], tagData[1], tagData[2], tagData[3])
: (tagData[0] << 24) | (tagData[1] << 16) | (tagData[2] << 8) | tagData[3];
offset += 4 + Math.max(0, extSize);
}
while (offset < tagData.length) {
if (tagData[offset] === 0x00) break;
if (verMajor === 2) {
// ID3v2.2: 3-byte frame ID, 3-byte size
if (offset + 6 > tagData.length) break;
const id = tagData.slice(offset, offset + 3).toString('latin1');
const size = (tagData[offset + 3] << 16) | (tagData[offset + 4] << 8) | tagData[offset + 5];
offset += 6;
if (!id.trim() || size <= 0 || offset + size > tagData.length) break;
if (id === 'PIC' && size > 6) {
const frame = tagData.slice(offset, offset + size);
const fmt = frame.slice(1, 4).toString('latin1').toLowerCase();
const mime = fmt === 'png' ? 'image/png' : 'image/jpeg';
// skip: encoding(1) + format(3) + pictureType(1) = 5, then null-terminated description
let p = 5;
const enc = frame[0];
const wide = enc === 1 || enc === 2;
const desc = readNullTerminated(frame as any, p, wide);
p = desc.next;
if (p < frame.length) {
const img = frame.slice(p);
if (img.length > 64) return { mime, data: Buffer.from(img) };
}
}
offset += size;
} else {
// ID3v2.3/v2.4: 4-byte frame ID, 4-byte size, 2-byte flags
if (offset + 10 > tagData.length) break;
const id = tagData.slice(offset, offset + 4).toString('latin1');
let size =
verMajor === 4
? synchsafeToInt(tagData[offset + 4], tagData[offset + 5], tagData[offset + 6], tagData[offset + 7])
: (tagData[offset + 4] << 24) |
(tagData[offset + 5] << 16) |
(tagData[offset + 6] << 8) |
tagData[offset + 7];
const flag2 = tagData[offset + 9];
offset += 10;
if (!id.trim() || size <= 0 || offset + size > tagData.length) break;
if (id === 'APIC') {
let frame = tagData.slice(offset, offset + size);
if (verMajor === 4 && (flag2 & 0x02) !== 0) frame = deUnsync(frame);
const enc = frame[0];
// mime type: null-terminated latin1
const mimeZ = readNullTerminated(frame as any, 1, false);
const mime = mimeZ.text || 'image/jpeg';
let p = mimeZ.next;
if (p < frame.length) p += 1; // picture type byte
const wide = enc === 1 || enc === 2;
const desc = readNullTerminated(frame as any, p, wide);
p = desc.next;
if (p < frame.length) {
const img = frame.slice(p);
if (img.length > 64) return { mime, data: Buffer.from(img) };
}
}
offset += size;
}
}
return null;
}
export async function GET(request: NextRequest, { params }: { params: { audioPath: string | string[] } }) {
const { audioPath } = await params;
try {
// Segments are already URL-decoded by Next.js; accepts both the legacy
// single-segment form and the `<folder>/<filename>` form.
const filepath = catchAllToFilePath(audioPath);
// Security check
const datasetRoot = await getDatasetsRoot();
const trainingRoot = await getTrainingFolder();
const dataRoot = await getDataRoot();
const allowedDirs = [datasetRoot, trainingRoot, dataRoot];
// Resolve so `..` segments collapse, then verify still under an allowed root.
// Substring `.includes('..')` false-positives on filenames containing `..` as text.
const resolved = path.resolve(filepath);
const isAllowed = allowedDirs.some(d => resolved === d || resolved.startsWith(d + path.sep));
if (!isAllowed) {
return new NextResponse('Access denied', { status: 403 });
}
const stat = await fs.promises.stat(resolved).catch(() => null);
if (!stat || !stat.isFile()) {
return new NextResponse('File not found', { status: 404 });
}
// Read only the ID3 tag (first min(tagSize, 4MB) bytes).
// First read 10 bytes to get tag size, then read the full tag.
const fd = await fs.promises.open(resolved, 'r');
try {
const headerBuf = Buffer.alloc(10);
await fd.read(headerBuf, 0, 10, 0);
if (headerBuf[0] !== 0x49 || headerBuf[1] !== 0x44 || headerBuf[2] !== 0x33) {
return new NextResponse('No ID3 tag', { status: 404 });
}
const tagSize = synchsafeToInt(headerBuf[6], headerBuf[7], headerBuf[8], headerBuf[9]);
const totalRead = Math.min(10 + tagSize, 4_000_000);
const tagBuf = Buffer.alloc(totalRead);
await fd.read(tagBuf, 0, totalRead, 0);
const art = extractArtFromTag(tagBuf);
if (!art) {
return new NextResponse('No album art found', { status: 404 });
}
return new NextResponse(art.data as any, {
headers: {
'Content-Type': art.mime,
'Content-Length': String(art.data.length),
'Cache-Control': 'public, max-age=604800, immutable',
},
});
} finally {
await fd.close();
}
} catch (error) {
console.error('Error extracting album art:', error);
return new NextResponse('Internal Server Error', { status: 500 });
}
}

Xet Storage Details

Size:
7.2 kB
·
Xet hash:
11910b0e1ca6249a75f7c3274ef3b2de291848a64e3916e2080f22f2a7317f65

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.