gating.go

package ebur128

import (
	"math"
	"sort"
)

const absGateLUFS = -70.0

// energy level corresponding to -70 LUFS
var absThreshold = math.Pow(10, (absGateLUFS+0.691)/10)

func energyToLoudness(energy float64) float64 {
	if energy < 1e-20 {
		return loudnessUnmeasurable
	}
	return -0.691 + 10*math.Log10(energy)
}

// 400ms blocks, 75% overlap, absolute + relative gate.
func integratedLoudness(subBlockEnergies []float64) (float64, int) {
	n := len(subBlockEnergies)
	if n < gatingBlocks {
		return loudnessUnmeasurable, 0
	}

	numBlocks := n - gatingBlocks + 1
	blockEnergies := make([]float64, numBlocks)
	for i := range numBlocks {
		var sum float64
		for j := range gatingBlocks {
			sum += subBlockEnergies[i+j]
		}
		blockEnergies[i] = sum / float64(gatingBlocks)
	}

	// first pass: absolute gate
	var sum float64
	var count int
	for _, e := range blockEnergies {
		if e >= absThreshold {
			sum += e
			count++
		}
	}
	if count == 0 {
		return loudnessUnmeasurable, 0
	}

	// second pass: relative gate (mean - 10 LU)
	meanEnergy := sum / float64(count)
	relThreshold := meanEnergy * math.Pow(10, -10.0/10.0)
	sum = 0
	count = 0
	for _, e := range blockEnergies {
		if e >= absThreshold && e >= relThreshold {
			sum += e
			count++
		}
	}
	if count == 0 {
		return loudnessUnmeasurable, 0
	}

	return energyToLoudness(sum / float64(count)), count
}

// 3s windows, 100ms step, 10th/95th percentile.
func loudnessRange(subBlockEnergies []float64) (float64, int) {
	n := len(subBlockEnergies)
	if n < shortTermBlocks {
		return 0.0, 0
	}

	numWindows := n - shortTermBlocks + 1
	windowEnergies := make([]float64, numWindows)
	for i := range numWindows {
		var sum float64
		for j := range shortTermBlocks {
			sum += subBlockEnergies[i+j]
		}
		windowEnergies[i] = sum / float64(shortTermBlocks)
	}

	var sum float64
	var count int
	for _, e := range windowEnergies {
		if e >= absThreshold {
			sum += e
			count++
		}
	}
	if count == 0 {
		return 0.0, 0
	}

	// relative gate: mean - 20 LU
	meanEnergy := sum / float64(count)
	relThreshold := meanEnergy * math.Pow(10, -20.0/10.0)
	gated := make([]float64, 0, count)
	for _, e := range windowEnergies {
		if e >= absThreshold && e >= relThreshold {
			gated = append(gated, energyToLoudness(e))
		}
	}
	if len(gated) < 2 {
		return 0.0, len(gated)
	}

	sort.Float64s(gated)

	low := percentile(gated, 0.10)
	high := percentile(gated, 0.95)
	return high - low, len(gated)
}

// ceil indexing per EBU TECH 3342
func percentile(sorted []float64, p float64) float64 {
	n := len(sorted)
	idx := int(math.Ceil(float64(n)*p)) - 1
	idx = max(idx, 0)
	if idx >= n {
		idx = n - 1
	}
	return sorted[idx]
}