ep-133-project-export/src/lib/exporters/ableton/automation.ts

import { FaderParam } from '../../../types/types';
import { AblGroupPatternOccurrence, AblTrack } from '../../transformers/ableton';
import {
  canonicalizeFilterFaderValue,
  convertGroupFaderValue,
  getFaderDefaultValue,
  getFaderPolicy,
} from './faderPolicies';

export type AbletonAutomationTarget = {
  arrangement?: number;
  session?: number;
  staticValue?: number;
  valueOffset?: number;
  padTrack?: AblTrack;
};

export type AbletonAutomationTargets = Partial<Record<FaderParam, AbletonAutomationTarget[]>>;

type AutomationPoint = {
  time: number;
  value: number;
};

const SENTINEL_TIME = -63072000;
const BOUNDARY_EPSILON = 0.000001;

export function convertFaderValue(
  parameter: FaderParam,
  value: number,
  track: AblTrack,
  groupMixer: boolean,
  target?: AbletonAutomationTarget,
) {
  return convertGroupFaderValue(parameter, value, {
    track: target?.padTrack ?? track,
    groupMixer,
    valueOffset: target?.valueOffset,
  });
}

export function getFaderValueAt(
  occurrence: AblGroupPatternOccurrence | undefined,
  parameter: FaderParam,
  position: number,
) {
  const staticValue = occurrence?.faderParams[parameter];
  let value = staticValue === undefined || staticValue === -1 ? undefined : staticValue;
  const points = (occurrence?.faderAutomation || [])
    .filter((point) => point.parameter === parameter && point.position <= position)
    .sort((a, b) => a.position - b.position);

  if (points.length > 0) {
    value = points[points.length - 1].value;
  }

  return value;
}

export function getScaledNoteVelocity(
  originalVelocity: number,
  occurrence: AblGroupPatternOccurrence | undefined,
  position: number,
) {
  const faderValue = getFaderValueAt(occurrence, FaderParam.VEL, position);
  const velocity = faderValue === undefined ? originalVelocity : originalVelocity * faderValue;
  return Math.max(1, Math.min(127, Math.round(velocity)));
}

function getStaticValue(pattern: AblGroupPatternOccurrence, parameter: FaderParam) {
  const value = pattern.faderParams[parameter];
  const staticValue = value === -1 ? getFaderDefaultValue(parameter) : value;
  if (parameter === FaderParam.LPF || parameter === FaderParam.HPF) {
    return canonicalizeFilterFaderValue(parameter, staticValue);
  }
  return staticValue;
}

function getConvertedStaticValue(
  pattern: AblGroupPatternOccurrence,
  parameter: FaderParam,
  track: AblTrack,
  groupMixer: boolean,
  target: AbletonAutomationTarget,
) {
  if (pattern.faderParams[parameter] === -1 && target.staticValue !== undefined) {
    return target.staticValue;
  }
  return convertFaderValue(
    parameter,
    getStaticValue(pattern, parameter),
    track,
    groupMixer,
    target,
  );
}

function getArrangementPoints(
  patterns: AblGroupPatternOccurrence[],
  parameter: FaderParam,
  track: AblTrack,
  groupMixer: boolean,
  target: AbletonAutomationTarget,
) {
  const orderedPatterns = patterns.toSorted((a, b) => {
    const offsetDifference = a.offset - b.offset;
    return offsetDifference || (a.occurrenceIndex ?? 0) - (b.occurrenceIndex ?? 0);
  });
  const hasAutomation = orderedPatterns.some((pattern) =>
    pattern.faderAutomation.some((point) => point.parameter === parameter),
  );
  if (!hasAutomation) {
    return [];
  }

  const points: AutomationPoint[] = [];
  let previousValue = orderedPatterns[0]
    ? getConvertedStaticValue(orderedPatterns[0], parameter, track, groupMixer, target)
    : convertFaderValue(parameter, getFaderDefaultValue(parameter), track, groupMixer, target);

  orderedPatterns.forEach((pattern) => {
    const patternTicks = Math.max(1, pattern.loopDuration * 96);
    const occurrenceTicks = Math.max(1, pattern.duration * 96);
    const startTime = pattern.offset;
    const sourcePoints = pattern.faderAutomation
      .filter((point) => point.parameter === parameter)
      .sort((a, b) => a.position - b.position);
    const staticValue = getConvertedStaticValue(pattern, parameter, track, groupMixer, target);

    points.push({ time: Math.max(0, startTime - BOUNDARY_EPSILON), value: previousValue });
    points.push({ time: startTime, value: staticValue });
    previousValue = staticValue;

    if (sourcePoints.length === 0) {
      return;
    }

    for (let loopOffset = 0; loopOffset < occurrenceTicks; loopOffset += patternTicks) {
      const loopStart = startTime + loopOffset / 96;
      if (loopOffset > 0) {
        points.push({ time: Math.max(0, loopStart - BOUNDARY_EPSILON), value: previousValue });
        points.push({ time: loopStart, value: staticValue });
        previousValue = staticValue;
      }

      sourcePoints.forEach((point) => {
        if (loopOffset + point.position >= occurrenceTicks) {
          return;
        }
        const value = convertFaderValue(parameter, point.value, track, groupMixer, target);
        points.push({ time: startTime + (loopOffset + point.position) / 96, value });
        previousValue = value;
      });
    }
  });

  return [{ time: SENTINEL_TIME, value: points[0]?.value ?? previousValue }, ...points];
}

function getClipPoints(
  pattern: AblGroupPatternOccurrence,
  parameter: FaderParam,
  track: AblTrack,
  groupMixer: boolean,
  target: AbletonAutomationTarget,
) {
  const sourcePoints = pattern.faderAutomation
    .filter((point) => point.parameter === parameter)
    .sort((a, b) => a.position - b.position);

  if (sourcePoints.length === 0) {
    return [];
  }

  const staticValue = getConvertedStaticValue(pattern, parameter, track, groupMixer, target);
  return [
    { time: SENTINEL_TIME, value: staticValue },
    { time: 0, value: staticValue },
    ...sourcePoints.map((point) => ({
      time: point.position / 96,
      value: convertFaderValue(parameter, point.value, track, groupMixer, target),
    })),
  ];
}

function floatEvents(points: AutomationPoint[]) {
  return points.map((point, index) => ({
    '@Id': index,
    '@Time': point.time,
    '@Value': point.value,
  }));
}

function automationContent(points: AutomationPoint[]) {
  return {
    Events: { FloatEvent: floatEvents(points) },
    AutomationTransformViewState: {
      IsTransformPending: { '@Value': 'false' },
      TimeAndValueTransforms: {},
    },
  };
}

export function buildArrangementEnvelopes(
  patterns: AblGroupPatternOccurrence[],
  targets: AbletonAutomationTargets,
  track: AblTrack,
  groupMixer: boolean,
) {
  const envelopes: any[] = [];
  Object.entries(targets).forEach(([parameterString, targetList]) => {
    const parameter = Number(parameterString) as FaderParam;
    if (getFaderPolicy(parameter).renderStrategy !== 'target') {
      return;
    }
    targetList?.forEach((target) => {
      if (target.arrangement === undefined) {
        return;
      }
      const points = getArrangementPoints(patterns, parameter, track, groupMixer, target);
      if (points.length === 0) {
        return;
      }
      envelopes.push({
        '@Id': envelopes.length,
        EnvelopeTarget: { PointeeId: { '@Value': target.arrangement } },
        Automation: automationContent(points),
      });
    });
  });
  return envelopes;
}

export function buildClipEnvelopes(
  pattern: AblGroupPatternOccurrence | undefined,
  targets: AbletonAutomationTargets,
  track: AblTrack,
  groupMixer: boolean,
) {
  if (!pattern) {
    return [];
  }

  const envelopes: any[] = [];
  Object.entries(targets).forEach(([parameterString, targetList]) => {
    const parameter = Number(parameterString) as FaderParam;
    if (getFaderPolicy(parameter).renderStrategy !== 'target') {
      return;
    }
    targetList?.forEach((target) => {
      if (target.session === undefined) {
        return;
      }
      const points = getClipPoints(pattern, parameter, track, groupMixer, target);
      if (points.length === 0) {
        return;
      }
      envelopes.push({
        '@Id': envelopes.length,
        EnvelopeTarget: { PointeeId: { '@Value': target.session } },
        Automation: automationContent(points),
        LoopSlot: { Value: {} },
        ScrollerTimePreserver: {
          LeftTime: { '@Value': 0 },
          RightTime: { '@Value': 0 },
        },
      });
    });
  });
  return envelopes;
}