523 lines
17 KiB
JavaScript
523 lines
17 KiB
JavaScript
const express = require('express');
|
|
const router = express.Router();
|
|
const axios = require('axios');
|
|
const { spawn } = require('child_process');
|
|
const db = require('../db');
|
|
const camelotToMusicKey = require('../../shared/camelot-to-musickey');
|
|
|
|
const reverseMap = {
|
|
// 12B / 12A (E-Dur / C#m / Dbm)
|
|
'e': '12B', 'e major': '12B', 'e-dur': '12B', 'e maj': '12B',
|
|
'c# minor': '12A', 'c#m': '12A', 'c#-moll': '12A', 'c# min': '12A',
|
|
'db minor': '12A', 'dbm': '12A', 'db-moll': '12A',
|
|
|
|
// 1B / 1A (B-Dur / H-Dur / G#m / Abm)
|
|
'b': '1B', 'b major': '1B', 'b-dur': '1B', 'b maj': '1B',
|
|
'h': '1B', 'h major': '1B', 'h-dur': '1B',
|
|
'g# minor': '1A', 'g#m': '1A', 'g#-moll': '1A', 'g# min': '1A',
|
|
'ab minor': '1A', 'abm': '1A', 'ab-moll': '1A',
|
|
|
|
// 2B / 2A (F#-Dur / Gb-Dur / D#m / Ebm)
|
|
'f#': '2B', 'f# major': '2B', 'f#-dur': '2B', 'f# maj': '2B',
|
|
'gb': '2B', 'gb major': '2B', 'gb-dur': '2B',
|
|
'd# minor': '2A', 'd#m': '2A', 'd#-moll': '2A', 'd# min': '2A',
|
|
'eb minor': '2A', 'ebm': '2A', 'eb-moll': '2A',
|
|
|
|
// 3B / 3A (Db-Dur / C#-Dur / Bbm / A#m)
|
|
'db': '3B', 'db major': '3B', 'db-dur': '3B', 'db maj': '3B',
|
|
'c#': '3B', 'c# major': '3B', 'c#-dur': '3B',
|
|
'bb minor': '3A', 'bbm': '3A', 'bb-moll': '3A', 'bb min': '3A',
|
|
'a# minor': '3A', 'a#m': '3A', 'a#-moll': '3A',
|
|
|
|
// 4B / 4A (Ab-Dur / G#-Dur / Fm)
|
|
'ab': '4B', 'ab major': '4B', 'ab-dur': '4B', 'ab maj': '4B',
|
|
'g#': '4B', 'g# major': '4B', 'g#-dur': '4B',
|
|
'f minor': '4A', 'fm': '4A', 'f-moll': '4A', 'f min': '4A',
|
|
|
|
// 5B / 5A (Eb-Dur / D#-Dur / Cm)
|
|
'eb': '5B', 'eb major': '5B', 'eb-dur': '5B', 'eb maj': '5B',
|
|
'd#': '5B', 'd# major': '5B', 'd#-dur': '5B',
|
|
'c minor': '5A', 'cm': '5A', 'c-moll': '5A', 'c min': '5A',
|
|
|
|
// 6B / 6A (Bb-Dur / A#-Dur / Gm)
|
|
'bb': '6B', 'bb major': '6B', 'bb-dur': '6B', 'bb maj': '6B',
|
|
'a#': '6B', 'a# major': '6B', 'a#-dur': '6B',
|
|
'g minor': '6A', 'gm': '6A', 'g-moll': '6A', 'g min': '6A',
|
|
|
|
// 7B / 7A (F-Dur / Dm)
|
|
'f': '7B', 'f major': '7B', 'f-dur': '7B', 'f maj': '7B',
|
|
'd minor': '7A', 'dm': '7A', 'd-moll': '7A', 'd min': '7A',
|
|
|
|
// 8B / 8A (C-Dur / Am)
|
|
'c': '8B', 'c major': '8B', 'c-dur': '8B', 'c maj': '8B',
|
|
'a minor': '8A', 'am': '8A', 'a-moll': '8A', 'a min': '8A',
|
|
|
|
// 9B / 9A (G-Dur / Em)
|
|
'g': '9B', 'g major': '9B', 'g-dur': '9B', 'g maj': '9B',
|
|
'e minor': '9A', 'em': '9A', 'e-moll': '9A', 'e min': '9A',
|
|
|
|
// 10B / 10A (D-Dur / Bm / Hm)
|
|
'd': '10B', 'd major': '10B', 'd-dur': '10B', 'd maj': '10B',
|
|
'b minor': '10A', 'bm': '10A', 'b-moll': '10A', 'b min': '10A',
|
|
'h minor': '10A', 'hm': '10A', 'h-moll': '10A', 'h min': '10A',
|
|
|
|
// 11B / 11A (A-Dur / F#m / Gbm)
|
|
'a': '11B', 'a major': '11B', 'a-dur': '11B', 'a maj': '11B',
|
|
'f# minor': '11A', 'f#m': '11A', 'f#-moll': '11A', 'f# min': '11A',
|
|
'gb minor': '11A', 'gbm': '11A', 'gb-moll': '11A',
|
|
};
|
|
|
|
function standardizeKey(keyString) {
|
|
if (!keyString) return null;
|
|
const str = keyString.toLowerCase().trim();
|
|
const upper = str.toUpperCase();
|
|
if (camelotToMusicKey[upper]) return upper;
|
|
return reverseMap[str] || null;
|
|
}
|
|
|
|
function estimateAudioFeatures(bpm, camelotKey, tags = []) {
|
|
let baseEnergy = Math.min(98, Math.max(35, Math.round(30 + ((bpm - 70) / 100) * 60)));
|
|
let baseDanceability = 70;
|
|
let baseHappiness = camelotKey && camelotKey.endsWith('B') ? 68 : 45;
|
|
|
|
const tagStr = (tags || []).join(' ').toLowerCase();
|
|
if (tagStr.includes('ambient') || tagStr.includes('acoustic') || tagStr.includes('chill')) {
|
|
baseEnergy = Math.max(25, baseEnergy - 30);
|
|
baseDanceability = Math.max(30, baseDanceability - 25);
|
|
}
|
|
if (tagStr.includes('tech') || tagStr.includes('club') || tagStr.includes('banger') || tagStr.includes('rave')) {
|
|
baseEnergy = Math.min(98, baseEnergy + 15);
|
|
baseDanceability = Math.min(95, baseDanceability + 12);
|
|
}
|
|
if (tagStr.includes('house') || tagStr.includes('disco') || tagStr.includes('dance')) {
|
|
baseDanceability = Math.min(92, baseDanceability + 10);
|
|
}
|
|
|
|
return {
|
|
energy: Math.min(99, Math.max(15, baseEnergy)),
|
|
danceability: Math.min(99, Math.max(20, baseDanceability)),
|
|
happiness: Math.min(99, Math.max(10, baseHappiness))
|
|
};
|
|
}
|
|
|
|
const MAJOR_PROFILE = [6.35, 2.23, 3.48, 2.33, 4.38, 4.09, 2.52, 5.19, 2.39, 3.66, 2.29, 2.88];
|
|
const MINOR_PROFILE = [6.33, 2.68, 3.52, 5.38, 2.60, 3.53, 2.54, 4.75, 3.98, 2.69, 3.34, 3.17];
|
|
const NOTE_NAMES = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'];
|
|
|
|
function normalizeTitle(str) {
|
|
if (!str) return '';
|
|
return str
|
|
.toLowerCase()
|
|
.replace(/\(.*?\)|\[.*?\]/g, '') // strip (feat. ...), [feat. ...]
|
|
.replace(/ - .*$/g, '') // strip trailing - Radio Edit, etc.
|
|
.replace(/[^a-z0-9]/g, ' ')
|
|
.replace(/\s+/g, ' ')
|
|
.trim();
|
|
}
|
|
|
|
function normalizeArtist(str) {
|
|
if (!str) return '';
|
|
const first = str.split(/,|&|feat\.|with|vs\./i)[0];
|
|
return first
|
|
.toLowerCase()
|
|
.replace(/[^a-z0-9]/g, ' ')
|
|
.replace(/\s+/g, ' ')
|
|
.trim();
|
|
}
|
|
|
|
function pearsonCorrelation(x, y) {
|
|
const n = x.length;
|
|
let sX = 0, sY = 0, sXY = 0, sX2 = 0, sY2 = 0;
|
|
for (let i = 0; i < n; i++) {
|
|
sX += x[i]; sY += y[i];
|
|
sXY += x[i] * y[i];
|
|
sX2 += x[i] * x[i]; sY2 += y[i] * y[i];
|
|
}
|
|
const den = Math.sqrt((n * sX2 - sX * sX) * (n * sY2 - sY * sY));
|
|
return den === 0 ? 0 : (n * sXY - sX * sY) / den;
|
|
}
|
|
|
|
function detectBpmFromSamples(samples, sampleRate) {
|
|
const frameSize = 512;
|
|
const numFrames = Math.floor(samples.length / frameSize);
|
|
if (numFrames < 20) return null;
|
|
|
|
const energies = new Float32Array(numFrames);
|
|
for (let i = 0; i < numFrames; i++) {
|
|
let sum = 0;
|
|
const off = i * frameSize;
|
|
for (let j = 0; j < frameSize; j++) {
|
|
const s = samples[off + j];
|
|
sum += s * s;
|
|
}
|
|
energies[i] = sum;
|
|
}
|
|
|
|
const onsets = new Float32Array(numFrames);
|
|
for (let i = 1; i < numFrames; i++) {
|
|
const diff = energies[i] - energies[i - 1];
|
|
onsets[i] = diff > 0 ? diff : 0;
|
|
}
|
|
|
|
const fps = sampleRate / frameSize;
|
|
const minLag = Math.floor((60 * fps) / 175);
|
|
const maxLag = Math.floor((60 * fps) / 75);
|
|
|
|
let bestLag = minLag;
|
|
let maxCorr = -Infinity;
|
|
|
|
for (let lag = minLag; lag <= maxLag; lag++) {
|
|
let corr = 0;
|
|
for (let i = 0; i < numFrames - lag; i++) {
|
|
corr += onsets[i] * onsets[i + lag];
|
|
}
|
|
if (corr > maxCorr) {
|
|
maxCorr = corr;
|
|
bestLag = lag;
|
|
}
|
|
}
|
|
|
|
return Math.round((60 * fps) / bestLag);
|
|
}
|
|
|
|
function detectKeyFromSamples(samples, sampleRate) {
|
|
const chroma = new Float64Array(12);
|
|
for (let midi = 36; midi <= 84; midi++) {
|
|
const freq = 440 * Math.pow(2, (midi - 69) / 12);
|
|
const pitchClass = midi % 12;
|
|
const k = Math.round((samples.length * freq) / sampleRate);
|
|
const omega = (2 * Math.PI * k) / samples.length;
|
|
const coeff = 2 * Math.cos(omega);
|
|
|
|
let sPrev = 0, sPrev2 = 0;
|
|
for (let i = 0; i < samples.length; i += 4) {
|
|
const s = samples[i] + coeff * sPrev - sPrev2;
|
|
sPrev2 = sPrev;
|
|
sPrev = s;
|
|
}
|
|
const power = sPrev2 * sPrev2 + sPrev * sPrev - coeff * sPrev * sPrev2;
|
|
if (power > 0) chroma[pitchClass] += Math.sqrt(power);
|
|
}
|
|
|
|
const maxChroma = Math.max(...chroma) || 1;
|
|
const normChroma = Array.from(chroma).map(v => v / maxChroma);
|
|
|
|
let bestScore = -Infinity;
|
|
let bestKeyStr = 'c major';
|
|
|
|
for (let root = 0; root < 12; root++) {
|
|
const shifted = [];
|
|
for (let i = 0; i < 12; i++) shifted.push(normChroma[(root + i) % 12]);
|
|
|
|
const corrMaj = pearsonCorrelation(shifted, MAJOR_PROFILE);
|
|
if (corrMaj > bestScore) {
|
|
bestScore = corrMaj;
|
|
bestKeyStr = `${NOTE_NAMES[root].toLowerCase()} major`;
|
|
}
|
|
const corrMin = pearsonCorrelation(shifted, MINOR_PROFILE);
|
|
if (corrMin > bestScore) {
|
|
bestScore = corrMin;
|
|
bestKeyStr = `${NOTE_NAMES[root].toLowerCase()} minor`;
|
|
}
|
|
}
|
|
|
|
const camelot = standardizeKey(bestKeyStr) || '8B';
|
|
return {
|
|
camelotKey: camelot,
|
|
confidence: Math.round(bestScore * 100)
|
|
};
|
|
}
|
|
|
|
function analyzeAudioPreview(previewUrl) {
|
|
return new Promise((resolve) => {
|
|
if (!previewUrl) return resolve(null);
|
|
|
|
const ffmpeg = spawn('ffmpeg', [
|
|
'-i', previewUrl,
|
|
'-f', 's16le',
|
|
'-ac', '1',
|
|
'-ar', '11025',
|
|
'-t', '25',
|
|
'-'
|
|
]);
|
|
|
|
const chunks = [];
|
|
ffmpeg.stdout.on('data', chunk => chunks.push(chunk));
|
|
ffmpeg.on('close', code => {
|
|
if (code !== 0 || chunks.length === 0) return resolve(null);
|
|
try {
|
|
const buf = Buffer.concat(chunks);
|
|
const numSamples = Math.floor(buf.length / 2);
|
|
const samples = new Float32Array(numSamples);
|
|
for (let i = 0; i < numSamples; i++) {
|
|
samples[i] = buf.readInt16LE(i * 2) / 32768.0;
|
|
}
|
|
|
|
const bpm = detectBpmFromSamples(samples, 11025);
|
|
const keyInfo = detectKeyFromSamples(samples, 11025);
|
|
|
|
if (bpm && keyInfo && keyInfo.camelotKey) {
|
|
return resolve({
|
|
bpm,
|
|
camelotKey: keyInfo.camelotKey,
|
|
confidence: keyInfo.confidence,
|
|
source: 'audio_analysis'
|
|
});
|
|
}
|
|
} catch (e) {
|
|
console.warn('[Metadata] Audio analysis error:', e.message);
|
|
}
|
|
resolve(null);
|
|
});
|
|
ffmpeg.on('error', (err) => {
|
|
console.warn('[Metadata] ffmpeg spawn error:', err.message);
|
|
resolve(null);
|
|
});
|
|
});
|
|
}
|
|
|
|
async function fetchSongBpm(artist, title) {
|
|
const normArt = normalizeArtist(artist);
|
|
const normTitle = normalizeTitle(title);
|
|
const variants = [
|
|
{ a: normArt, t: normTitle },
|
|
{ a: artist, t: title }
|
|
];
|
|
|
|
for (const v of variants) {
|
|
const aSlug = v.a.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
|
|
const tSlug = v.t.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
|
|
if (!aSlug || !tSlug) continue;
|
|
|
|
try {
|
|
const r = await axios.get(`https://songbpm.com/@${aSlug}/${tSlug}`, {
|
|
headers: { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)' },
|
|
timeout: 3500
|
|
});
|
|
const kMatch = r.data.match(/<span class="font-semibold">([A-G][b#]?)<\/span>\s*key\s*and\s*a\s*<span class="font-semibold">(minor|major)<\/span>\s*mode/i);
|
|
const bpmMatch = r.data.match(/(\d+)\s*<span class="pl-1 text-sm">\s*BPM<\/span>/i);
|
|
if (kMatch && bpmMatch) {
|
|
const fullKey = `${kMatch[1].toLowerCase()} ${kMatch[2].toLowerCase()}`;
|
|
const camelot = standardizeKey(fullKey);
|
|
const bpm = parseInt(bpmMatch[1], 10);
|
|
if (camelot && bpm) {
|
|
return { bpm, camelotKey: camelot, source: 'songbpm' };
|
|
}
|
|
}
|
|
} catch (e) {
|
|
// ignore
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
router.get('/', async (req, res) => {
|
|
const track = req.query.track;
|
|
const artist = req.query.artist;
|
|
|
|
if (!track || !artist) {
|
|
return res.status(400).json({ error: 'Missing track or artist' });
|
|
}
|
|
|
|
try {
|
|
// 1. Check PostgreSQL first (exact + fuzzy match on 26,000+ tracks)
|
|
const local = await db.findTrack(artist, track);
|
|
if (local && local.camelot_key && local.bpm) {
|
|
const est = estimateAudioFeatures(local.bpm, local.camelot_key, local.tags);
|
|
return res.json({
|
|
status: 'success',
|
|
data: {
|
|
key: local.camelot_key,
|
|
bpm: local.bpm,
|
|
music_key: local.music_key || camelotToMusicKey[local.camelot_key] || '',
|
|
tags: local.tags || ['dance'],
|
|
is_corrected: !!local.is_corrected,
|
|
cover_url: local.cover_url || null,
|
|
preview_url: local.preview_url || null,
|
|
deezer_id: local.deezer_id || null,
|
|
deezer_link: local.deezer_link || (local.deezer_id ? `https://www.deezer.com/track/${local.deezer_id}` : null),
|
|
duration_sec: local.duration_sec || 210,
|
|
energy: local.energy || est.energy,
|
|
danceability: local.danceability || est.danceability,
|
|
happiness: local.happiness || est.happiness,
|
|
source: local.source || 'postgresql'
|
|
}
|
|
});
|
|
}
|
|
|
|
let bpm = null;
|
|
let camelotKey = null;
|
|
let tags = [];
|
|
let coverUrl = null;
|
|
let durationSec = 210;
|
|
let previewUrl = null;
|
|
let deezerLink = null;
|
|
let deezerId = null;
|
|
let detectedSource = null;
|
|
|
|
// 2. Query Deezer for cover, duration, preview, and deezer links
|
|
try {
|
|
const deezerRes = await axios.get(`https://api.deezer.com/search?q=${encodeURIComponent(artist + ' ' + track)}&limit=1`, {
|
|
timeout: 3500
|
|
});
|
|
if (deezerRes.data && deezerRes.data.data && deezerRes.data.data[0]) {
|
|
const dTrack = deezerRes.data.data[0];
|
|
if (dTrack.album && dTrack.album.cover_medium) {
|
|
coverUrl = dTrack.album.cover_medium;
|
|
}
|
|
if (dTrack.duration) {
|
|
durationSec = dTrack.duration;
|
|
}
|
|
if (dTrack.preview) {
|
|
previewUrl = dTrack.preview;
|
|
}
|
|
if (dTrack.link) {
|
|
deezerLink = dTrack.link;
|
|
}
|
|
if (dTrack.id) {
|
|
deezerId = dTrack.id;
|
|
if (!deezerLink) deezerLink = `https://www.deezer.com/track/${dTrack.id}`;
|
|
}
|
|
}
|
|
} catch (e) {
|
|
// ignore
|
|
}
|
|
|
|
// 3. Try SongBPM lookup (exact calibrated musical data)
|
|
const songBpmHit = await fetchSongBpm(artist, track);
|
|
if (songBpmHit) {
|
|
bpm = songBpmHit.bpm;
|
|
camelotKey = songBpmHit.camelotKey;
|
|
detectedSource = songBpmHit.source;
|
|
}
|
|
|
|
// 4. Query GetSongBPM API with normalized clean parameters if key still missing
|
|
if (!camelotKey && process.env.GETSONGBPM_API_KEY) {
|
|
try {
|
|
const cleanTitle = normalizeTitle(track);
|
|
const cleanArtist = normalizeArtist(artist);
|
|
const gsbRes = await axios.get('https://api.getsong.co/search/', {
|
|
params: {
|
|
api_key: process.env.GETSONGBPM_API_KEY,
|
|
type: 'both',
|
|
lookup: `song:${cleanTitle} artist:${cleanArtist}`
|
|
},
|
|
timeout: 4000
|
|
});
|
|
|
|
const searchResults = gsbRes.data && gsbRes.data.search;
|
|
if (Array.isArray(searchResults) && searchResults.length > 0) {
|
|
const song = searchResults[0];
|
|
if (song.tempo && !bpm) {
|
|
bpm = parseFloat(song.tempo);
|
|
}
|
|
if (song.key_of) {
|
|
camelotKey = standardizeKey(song.key_of);
|
|
if (camelotKey) detectedSource = 'getsongbpm';
|
|
}
|
|
if (song.artist && song.artist.genres && tags.length === 0) {
|
|
tags = song.artist.genres.slice(0, 4);
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.warn('[Metadata] GetSongBPM Error:', err.message);
|
|
}
|
|
}
|
|
|
|
// 5. Real-time Audio Preview Analysis via ffmpeg if key still not determined
|
|
if ((!camelotKey || !bpm) && previewUrl) {
|
|
try {
|
|
const audioHit = await analyzeAudioPreview(previewUrl);
|
|
if (audioHit) {
|
|
if (!bpm && audioHit.bpm) bpm = audioHit.bpm;
|
|
if (!camelotKey && audioHit.camelotKey) {
|
|
camelotKey = audioHit.camelotKey;
|
|
detectedSource = audioHit.source;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.warn('[Metadata] Audio analysis failed:', err.message);
|
|
}
|
|
}
|
|
|
|
// 6. Last.fm API for genre tags
|
|
if (process.env.LASTFM_API_KEY && tags.length === 0) {
|
|
try {
|
|
const lfmRes = await axios.get('https://ws.audioscrobbler.com/2.0/', {
|
|
params: {
|
|
method: 'track.getInfo',
|
|
api_key: process.env.LASTFM_API_KEY,
|
|
artist: normalizeArtist(artist),
|
|
track: normalizeTitle(track),
|
|
format: 'json'
|
|
},
|
|
timeout: 3500
|
|
});
|
|
|
|
if (lfmRes.data && lfmRes.data.track && lfmRes.data.track.toptags && lfmRes.data.track.toptags.tag) {
|
|
tags = lfmRes.data.track.toptags.tag
|
|
.slice(0, 4)
|
|
.map(t => t.name.toLowerCase());
|
|
}
|
|
} catch (err) {
|
|
console.warn('[Metadata] Last.fm Error:', err.message);
|
|
}
|
|
}
|
|
|
|
if (tags.length === 0) tags = ['electronic', 'dance'];
|
|
|
|
const hasRealKey = !!camelotKey;
|
|
const finalBpm = bpm ? Math.round(bpm) : 120;
|
|
const finalKey = camelotKey || '8B';
|
|
const finalSource = detectedSource || (hasRealKey ? 'online' : 'unverified');
|
|
const musicKey = camelotToMusicKey[finalKey] || '';
|
|
const audioAttrs = estimateAudioFeatures(finalBpm, finalKey, tags);
|
|
|
|
// 7. Persist only if key was legitimately determined (do NOT pollute DB with blind unverified 8B)
|
|
if (hasRealKey) {
|
|
await db.saveTrack({
|
|
title: track,
|
|
artist: artist,
|
|
camelot_key: finalKey,
|
|
bpm: finalBpm,
|
|
music_key: musicKey,
|
|
cover_url: coverUrl,
|
|
preview_url: previewUrl,
|
|
duration_sec: durationSec,
|
|
energy: audioAttrs.energy,
|
|
danceability: audioAttrs.danceability,
|
|
happiness: audioAttrs.happiness,
|
|
tags: tags,
|
|
is_corrected: false,
|
|
source: finalSource
|
|
});
|
|
}
|
|
|
|
res.json({
|
|
status: 'success',
|
|
data: {
|
|
key: finalKey,
|
|
bpm: finalBpm,
|
|
music_key: musicKey,
|
|
tags: tags,
|
|
is_corrected: false,
|
|
cover_url: coverUrl,
|
|
preview_url: previewUrl,
|
|
duration_sec: durationSec,
|
|
deezer_id: deezerId,
|
|
deezer_link: deezerLink,
|
|
energy: audioAttrs.energy,
|
|
danceability: audioAttrs.danceability,
|
|
happiness: audioAttrs.happiness,
|
|
source: finalSource
|
|
}
|
|
});
|
|
|
|
} catch (err) {
|
|
console.error('[Metadata] error:', err.message);
|
|
res.status(500).json({ error: 'Failed to fetch metadata' });
|
|
}
|
|
});
|
|
|
|
module.exports = router;
|