1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
import { hasKeyframesForPath } from "@/animation/keyframe-query";
import { resolveNumberAtTime } from "@/animation/values";
import { VOLUME_DB_MAX, VOLUME_DB_MIN } from "./audio-constants";
import type { TimelineElement } from "./types";
const DEFAULT_STEP_SECONDS = 1 / 60;
export type AudioCapableElement = Extract<
TimelineElement,
{ type: "audio" | "video" }
>;
export function clampDb(value: number): number {
if (!Number.isFinite(value)) {
return 0;
}
return Math.min(VOLUME_DB_MAX, Math.max(VOLUME_DB_MIN, value));
}
export function dBToLinear(db: number): number {
return 10 ** (clampDb(db) / 20);
}
export function hasAnimatedVolume({
element,
}: {
element: AudioCapableElement;
}): boolean {
return hasKeyframesForPath({
animations: element.animations,
propertyPath: "volume",
});
}
import { TICKS_PER_SECOND } from "@/wasm";
export function resolveEffectiveAudioGain({
element,
trackMuted = false,
localTime,
}: {
element: AudioCapableElement;
trackMuted?: boolean;
localTime: number;
}): number {
if (trackMuted || element.muted === true) {
return 0;
}
const resolvedDb = resolveNumberAtTime({
baseValue: element.volume ?? 0,
animations: element.animations,
propertyPath: "volume",
localTime: Math.round(localTime * TICKS_PER_SECOND),
});
return dBToLinear(resolvedDb);
}
export function buildWaveformGainSamples({
element,
count,
}: {
element: AudioCapableElement;
count: number;
}): number[] {
const durationSeconds = element.duration / TICKS_PER_SECOND;
return Array.from({ length: count }, (_, i) => {
const localTime = ((i + 0.5) / count) * durationSeconds;
return resolveEffectiveAudioGain({ element, localTime });
});
}
export function buildAudioGainAutomation({
element,
trackMuted = false,
fromLocalTime,
toLocalTime,
stepSeconds = DEFAULT_STEP_SECONDS,
}: {
element: AudioCapableElement;
trackMuted?: boolean;
fromLocalTime: number;
toLocalTime: number;
stepSeconds?: number;
}): Array<{ localTime: number; gain: number }> {
const startTime = Math.max(0, fromLocalTime);
const endTime = Math.max(startTime, toLocalTime);
const safeStep =
Number.isFinite(stepSeconds) && stepSeconds > 0
? stepSeconds
: DEFAULT_STEP_SECONDS;
const points: Array<{ localTime: number; gain: number }> = [];
for (let localTime = startTime; localTime < endTime; localTime += safeStep) {
points.push({
localTime,
gain: resolveEffectiveAudioGain({
element,
trackMuted,
localTime,
}),
});
}
points.push({
localTime: endTime,
gain: resolveEffectiveAudioGain({
element,
trackMuted,
localTime: endTime,
}),
});
return points;
}
|
