Files
shumai/packages/core/src/transcode/transcode.ts
T
Yiling-J b52b2ce7d8 fix(transcode): preserve trashed status during background jobs and handle permanent purge (#416)
* fix(transcode): preserve trashed status during background jobs and handle permanent purge

* fix(workflow): clear heartbeat and add info logs on task cancellation

* fix(transcode): terminate media processes and guard task activities on cancellation

- Pass AbortSignal to ffmpeg and pdftoppm child processes in transcodeService to terminate processes on task cancellation
- Add local task AbortController context and cancellation guards in executeActivity to prevent subsequent workflow activities
- Forward taskId and cancellation signals in transcode, screenshot, and PDF activities
- Use updateMany instead of update in task activities to eliminate Prisma P2025 errors on purged task records

* fix(workflow): allow cleanup activities in finally blocks during task cancellation

Remove blanket cancellation check in executeActivity so that workflows can execute cleanup and failure handling activities in catch and finally blocks upon cancellation, while relying on AbortSignal in active activities to abort execution.

* docs(changelog): improve user friendliness of changelog entries and formatting example

* docs(agents): update changelog guidelines to emphasize end-user friendly descriptions

* fix(transcode): handle queued cancellation and delete races in media workflow
2026-09-19 10:40:49 +08:00

1612 lines
50 KiB
TypeScript

import { s3Service } from '@shumai/core/src/s3/s3'
import { getDerivedArtifactDirectory, stemFromKey } from '@shumai/core/src/utils/filename'
import { prisma, WorkflowTaskStatus, WorkflowTaskType } from '@shumai/db'
import '@shumai/db/src/prisma-json-types'
import { execFile } from 'child_process'
import { parse } from 'csv-parse/sync'
import * as fs from 'fs'
import * as os from 'os'
import * as path from 'path'
import PDFDocument from 'pdfkit'
import sharp from 'sharp'
import { ulid } from 'ulid'
import { promisify } from 'util'
import { mapConcurrent } from '../utils/async'
import { dataFormatNames } from './dataFormatNames'
const execFileAsync = promisify(execFile)
export interface CjkFontConfig {
fontPath: string
fontName?: string
}
export function findCjkFontPath(): CjkFontConfig | undefined {
const candidates: { fontPath: string; fontName?: string }[] = [
// Custom env override
...(process.env.PDF_CJK_FONT_PATH
? [
{
fontPath: process.env.PDF_CJK_FONT_PATH,
fontName: process.env.PDF_CJK_FONT_NAME,
},
]
: []),
// macOS
{ fontPath: '/System/Library/Fonts/Supplemental/Arial Unicode.ttf' },
{ fontPath: '/Library/Fonts/Arial Unicode.ttf' },
{ fontPath: '/System/Library/Fonts/PingFang.ttc', fontName: 'PingFangSC-Regular' },
{ fontPath: '/System/Library/Fonts/STHeiti Light.ttc', fontName: 'STHeitiSC-Light' },
// Linux / Ubuntu / Debian Noto & WenQuanYi CJK
{
fontPath: '/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc',
fontName: 'NotoSansCJKsc-Regular',
},
{
fontPath: '/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc',
fontName: 'NotoSansCJKsc-Regular',
},
{ fontPath: '/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc', fontName: 'WenQuanYiZenHei' },
{ fontPath: '/usr/share/fonts/truetype/arphic/ukai.ttc', fontName: 'AR-PL-UKai-CN' },
{
fontPath: '/usr/share/fonts/noto/NotoSansCJK-Regular.ttc',
fontName: 'Noto Sans CJK SC',
},
// Lightweight Linux / Docker Droid Fallbacks
{ fontPath: '/usr/share/fonts/truetype/droid/DroidSansFallbackFull.ttf' },
{ fontPath: '/usr/share/fonts/truetype/droid/DroidSansFallback.ttf' },
{ fontPath: '/usr/share/fonts/google-droid/DroidSansFallback.ttf' },
// Windows CJK Fonts
{ fontPath: 'C:\\Windows\\Fonts\\msyh.ttc', fontName: 'MicrosoftYaHei' },
{ fontPath: 'C:\\Windows\\Fonts\\simsun.ttc', fontName: 'SimSun' },
{ fontPath: 'C:\\Windows\\Fonts\\simhei.ttf' },
]
for (const item of candidates) {
if (fs.existsSync(item.fontPath)) {
return item
}
}
return undefined
}
export function parseCsvContent(content: string): string[][] {
try {
/* eslint-disable @typescript-eslint/naming-convention */
return parse(content, {
skip_empty_lines: true,
relax_column_count: true,
relax_quotes: true,
trim: true,
delimiter_auto: true,
})
} catch {
return content
.split(/\r?\n/)
.filter((line) => line.trim().length > 0)
.map((line) => line.split(',').map((cell) => cell.trim()))
}
}
export interface MediaMetadata {
originalWidth: number
originalHeight: number
duration: number
bitRate: number
videoBitRate?: number
frameRate: number
totalFrames: number
startTimecode?: string
hasAudio: boolean
videoCodec?: string
audioCodec?: string
audioChannels?: number
audioSampleRate?: number
audioBitDepth?: number
mimeType: string
}
export interface TranscodeVideoParams {
inputFile: string
outputFile: string
width: number
height: number
frameRate?: number | string
disableAudio?: boolean
overlayFile?: string
hardwareAcceleration?: 'off' | 'auto'
videoBitrate?: string
sourceVideoBitrate?: number
threads?: number
signal?: AbortSignal
}
export interface EncoderConfig {
name: string
presetArgs: string[]
}
export const H264_ENCODER_CONFIGS: Record<string, EncoderConfig> = {
h264_nvenc: {
name: 'h264_nvenc',
presetArgs: ['-preset', 'p4', '-rc:v', 'vbr', '-cq:v', '26', '-b:v', '0'],
},
h264_qsv: {
name: 'h264_qsv',
presetArgs: ['-preset', 'fast', '-global_quality', '26'],
},
h264_amf: {
name: 'h264_amf',
presetArgs: ['-quality', 'balanced', '-rc', 'qvbr', '-qvbr_quality_level', '26'],
},
h264_videotoolbox: {
name: 'h264_videotoolbox',
presetArgs: ['-q:v', '74'],
},
libx264: {
name: 'libx264',
presetArgs: ['-preset', 'fast', '-crf', '26'],
},
}
export function getPlatformEncoderCandidates(
platform: NodeJS.Platform = process.platform,
): string[] {
switch (platform) {
case 'darwin':
return ['h264_videotoolbox', 'h264_nvenc', 'h264_qsv', 'h264_amf']
case 'win32':
return ['h264_nvenc', 'h264_qsv', 'h264_amf']
case 'linux':
default:
return ['h264_nvenc', 'h264_qsv', 'h264_amf']
}
}
export function getDefaultBitrateBps(height: number, width?: number): number {
const longSide = Math.max(width || 0, height)
const shortSide = Math.min(width || height, height)
const effectiveHeight = shortSide > 0 ? shortSide : height
if (effectiveHeight >= 2160 || longSide >= 3840) return 12_000_000
if (effectiveHeight >= 1080 || longSide >= 1920) return 4_500_000
if (effectiveHeight >= 720 || longSide >= 1280) return 2_500_000
if (effectiveHeight >= 540 || longSide >= 960) return 1_200_000
if (effectiveHeight >= 360 || longSide >= 640) return 800_000
return 100_000
}
export function getDefaultBitrate(height: number, width?: number): string {
const bps = getDefaultBitrateBps(height, width)
return `${Math.round(bps / 1000)}k`
}
export function calculateMaxBitrate(
targetHeight: number,
targetWidth?: number,
sourceVideoBitrate?: number,
targetFps?: number | string,
): { maxrate: string; bufsize: string } {
let configuredMaxBps = getDefaultBitrateBps(targetHeight, targetWidth)
// If frame rate is downsampled (e.g. 180p preview with < 24 fps), scale the bitrate ceiling proportionally
if (targetFps) {
let parsedFps: number | undefined
if (typeof targetFps === 'number') {
parsedFps = targetFps
} else {
const parts = targetFps.split('/')
if (parts.length === 2) {
parsedFps = parseFloat(parts[0]) / parseFloat(parts[1])
} else {
parsedFps = parseFloat(targetFps)
}
}
if (Number.isFinite(parsedFps) && parsedFps > 0 && parsedFps < 24) {
const fpsRatio = Math.max(0.1, parsedFps / 24)
configuredMaxBps = Math.max(50_000, Math.round(configuredMaxBps * fpsRatio))
}
}
let effectiveMaxBps =
sourceVideoBitrate && sourceVideoBitrate > 0
? Math.min(configuredMaxBps, Math.round(sourceVideoBitrate * 1.2))
: configuredMaxBps
const minFloor = targetFps ? 50_000 : 100_000
effectiveMaxBps = Math.max(minFloor, effectiveMaxBps)
const maxrateKbps = Math.max(50, Math.round(effectiveMaxBps / 1000))
const bufsizeKbps = maxrateKbps * 2
return {
maxrate: `${maxrateKbps}k`,
bufsize: `${bufsizeKbps}k`,
}
}
export interface ExtractVideoFramesParams {
inputFile: string
outputDir: string
numFrames: number
frameHeight: number
isImage: boolean
}
export function isPsdInput(input: string | Buffer): boolean {
if (typeof input === 'string') {
if (input.toLowerCase().endsWith('.psd')) return true
if (fs.existsSync(input)) {
try {
const fd = fs.openSync(input, 'r')
const buf = Buffer.alloc(4)
fs.readSync(fd, buf, 0, 4, 0)
fs.closeSync(fd)
return buf.toString('ascii') === '8BPS'
} catch {
return false
}
}
return false
}
return (
input.length >= 4 &&
input[0] === 0x38 &&
input[1] === 0x42 &&
input[2] === 0x50 &&
input[3] === 0x53
)
}
export function calculatePreviewDimensions(
origW: number,
origH: number,
targetShort = 300,
maxLong = 533,
): { width: number; height: number } {
if (origW <= 0 || origH <= 0) {
return { width: targetShort, height: targetShort }
}
const origShort = Math.min(origW, origH)
const origLong = Math.max(origW, origH)
if (origShort <= targetShort && origLong <= maxLong) {
return { width: origW, height: origH }
}
let scale = targetShort / origShort
const scaledLong = Math.round(origLong * scale)
if (scaledLong > maxLong) {
scale = maxLong / origLong
}
const newW = Math.max(1, Math.round(origW * scale))
const newH = Math.max(1, Math.round(origH * scale))
return { width: newW, height: newH }
}
export interface TranscodeImageOptions {
height?: number | null
isPreview?: boolean
}
export class TranscodeService {
constructor(private readonly prismaClient: typeof prisma = prisma) {}
private async execImageMagick(args: string[]): Promise<{ stdout: string; stderr: string }> {
try {
return await execFileAsync('magick', args)
} catch (err: unknown) {
const code = (err as Record<string, unknown>)?.code
if (code === 'ENOENT') {
return await execFileAsync('convert', args)
}
throw err
}
}
private async execImageMagickIdentify(
filePath: string,
): Promise<{ width: number; height: number }> {
const fileArg = `${filePath}[0]`
let stdout: string
try {
const res = await execFileAsync('magick', ['identify', '-format', '%w %h', fileArg])
stdout = res.stdout
} catch (err: unknown) {
const code = (err as Record<string, unknown>)?.code
if (code === 'ENOENT') {
const res = await execFileAsync('identify', ['-format', '%w %h', fileArg])
stdout = res.stdout
} else {
throw err
}
}
const parts = stdout.trim().split(/\s+/)
const width = parseInt(parts[0], 10) || 0
const height = parseInt(parts[1], 10) || 0
return { width, height }
}
private resolveCodecName(stream: {
/* eslint-disable @typescript-eslint/naming-convention */
codec_name?: string
mime_codec_string?: string
tags?: { mime_codec_string?: string }
/* eslint-enable @typescript-eslint/naming-convention */
}): string | undefined {
const mimeCodec = stream.mime_codec_string || stream.tags?.mime_codec_string
if (mimeCodec && typeof mimeCodec === 'string') {
const shortCodec = mimeCodec.split('.')[0]
if (dataFormatNames[shortCodec]) {
return dataFormatNames[shortCodec]
}
}
return stream.codec_name
}
private safeParseInt(value: string | number | undefined): number | undefined {
if (value === undefined || value === null) return undefined
const parsed = typeof value === 'string' ? parseInt(value, 10) : value
return Number.isFinite(parsed) ? (parsed as number) : undefined
}
async getVideoInfo(inputFile: string): Promise<MediaMetadata> {
const { stdout } = await execFileAsync('ffprobe', [
'-v',
'quiet',
'-print_format',
'json',
'-show_format',
'-show_streams',
inputFile,
])
const info = JSON.parse(stdout)
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const videoStream = info.streams.find((s: any) => s.codec_type === 'video')
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const audioStream = info.streams.find((s: any) => s.codec_type === 'audio')
if (!videoStream) {
throw new Error('No video stream found')
}
let fps = 0
if (videoStream.avg_frame_rate) {
const parts = videoStream.avg_frame_rate.split('/')
if (parts.length === 2) {
const num = parseFloat(parts[0])
const den = parseFloat(parts[1])
if (den > 0) {
fps = num / den
}
}
}
if (fps === 0 && videoStream.r_frame_rate) {
const parts = videoStream.r_frame_rate.split('/')
if (parts.length === 2) {
const num = parseFloat(parts[0])
const den = parseFloat(parts[1])
if (den > 0) {
fps = num / den
}
}
}
const duration = parseFloat(info.format.duration)
let totalFrames = 0
if (videoStream.nb_frames) {
totalFrames = parseInt(videoStream.nb_frames, 10)
}
if (!totalFrames && fps > 0 && !isNaN(duration)) {
totalFrames = Math.round(duration * fps)
}
const startTimecode = videoStream.tags?.timecode || info.format?.tags?.timecode
let videoBitRate: number | undefined
if (videoStream.bit_rate && parseInt(videoStream.bit_rate, 10) > 0) {
videoBitRate = parseInt(videoStream.bit_rate, 10)
} else {
const bpsTag = videoStream.tags?.BPS || videoStream.tags?.['BPS-eng']
if (bpsTag && parseInt(bpsTag, 10) > 0) {
videoBitRate = parseInt(bpsTag, 10)
} else {
const bytesTag =
videoStream.tags?.NUMBER_OF_BYTES || videoStream.tags?.['NUMBER_OF_BYTES-eng']
if (bytesTag && duration > 0) {
videoBitRate = Math.round((parseInt(bytesTag, 10) * 8) / duration)
} else {
const totalBitrate = parseFloat(info.format.bit_rate)
if (Number.isFinite(totalBitrate) && totalBitrate > 0) {
const audioBitrate = audioStream?.bit_rate
? parseFloat(audioStream.bit_rate)
: audioStream
? 128_000
: 0
videoBitRate = Math.max(100_000, Math.round(totalBitrate - audioBitrate))
}
}
}
}
return {
originalWidth: videoStream.width,
originalHeight: videoStream.height,
duration,
bitRate: parseFloat(info.format.bit_rate),
videoBitRate,
frameRate: fps || 30,
totalFrames: totalFrames || 0,
startTimecode,
hasAudio: !!audioStream,
videoCodec: this.resolveCodecName(videoStream),
audioCodec: audioStream ? this.resolveCodecName(audioStream) : undefined,
audioChannels: audioStream?.channels,
audioSampleRate: this.safeParseInt(audioStream?.sample_rate),
audioBitDepth:
this.safeParseInt(audioStream?.bits_per_raw_sample) ??
this.safeParseInt(audioStream?.bits_per_sample),
mimeType: '',
}
}
async getImageInfo(inputFile: string): Promise<MediaMetadata> {
let input: string | Buffer = inputFile
let tempDirToCleanup: string | null = null
if (inputFile.startsWith('http')) {
const resp = await fetch(inputFile)
if (!resp.ok) {
throw new Error(`Failed to fetch image from ${inputFile}: ${resp.statusText}`)
}
input = Buffer.from(await resp.arrayBuffer())
}
if (isPsdInput(input)) {
let psdPath: string
if (typeof input === 'string') {
psdPath = input
} else {
tempDirToCleanup = this.createTempDir('psd-info-')
psdPath = path.join(tempDirToCleanup, 'input.psd')
fs.writeFileSync(psdPath, input)
}
try {
const { width, height } = await this.execImageMagickIdentify(psdPath)
return {
originalWidth: width,
originalHeight: height,
duration: 0,
bitRate: 0,
frameRate: 0,
totalFrames: 0,
startTimecode: undefined,
hasAudio: false,
mimeType: 'psd',
}
} catch (err) {
console.warn('ImageMagick identify failed for PSD, falling back to sharp:', err)
} finally {
if (tempDirToCleanup) {
this.removeDir(tempDirToCleanup)
}
}
}
const metadata = await sharp(input, { limitInputPixels: false }).metadata()
return {
originalWidth: metadata.width || 0,
originalHeight: metadata.height || 0,
duration: 0,
bitRate: 0,
frameRate: 0,
totalFrames: 0,
startTimecode: undefined,
hasAudio: false,
mimeType: metadata.format || '',
}
}
private availableEncodersCache: Set<string> | null = null
clearEncodersCache(): void {
this.availableEncodersCache = null
}
async getAvailableEncoders(): Promise<Set<string>> {
if (this.availableEncodersCache) {
return this.availableEncodersCache
}
try {
const { stdout } = await execFileAsync('ffmpeg', ['-encoders'])
const encoders = new Set<string>()
const lines = stdout.split('\n')
for (const line of lines) {
const match = line.match(/^\s*[A-Z.]{6}\s+([a-zA-Z0-9_-]+)/)
if (match) {
encoders.add(match[1])
}
}
this.availableEncodersCache = encoders
return encoders
} catch (err) {
console.warn('Failed to probe ffmpeg encoders:', err)
return new Set<string>()
}
}
async selectH264Encoder(
hardwareAcceleration?: 'off' | 'auto',
platform: NodeJS.Platform = process.platform,
): Promise<EncoderConfig> {
if (hardwareAcceleration !== 'auto') {
return H264_ENCODER_CONFIGS.libx264
}
const available = await this.getAvailableEncoders()
const candidates = getPlatformEncoderCandidates(platform)
for (const enc of candidates) {
if (available.has(enc) && H264_ENCODER_CONFIGS[enc]) {
return H264_ENCODER_CONFIGS[enc]
}
}
return H264_ENCODER_CONFIGS.libx264
}
async transcodeVideo(params: TranscodeVideoParams): Promise<void> {
let filterComplex: string
const args: string[] = ['-i', params.inputFile]
if (params.overlayFile) {
args.push('-i', params.overlayFile)
filterComplex = `[0:v]scale=${params.width}:${params.height}[vscaled];[vscaled][1:v]overlay=0:0`
} else {
filterComplex = `[0:v]scale=w=${params.width}:h=${params.height}:force_original_aspect_ratio=decrease,scale=w='trunc(iw/2)*2':h='trunc(ih/2)*2'`
}
if (params.frameRate) {
filterComplex += `,fps=${params.frameRate}`
}
filterComplex += '[vout]'
args.push('-filter_complex', filterComplex, '-map', '[vout]')
if (params.frameRate) {
let calculatedFps: number
if (typeof params.frameRate === 'number') {
calculatedFps = params.frameRate
} else {
const parts = params.frameRate.split('/')
if (parts.length === 2) {
calculatedFps = parseFloat(parts[0]) / parseFloat(parts[1])
} else {
calculatedFps = parseFloat(params.frameRate)
}
}
if (Number.isFinite(calculatedFps) && calculatedFps > 0) {
const roundedFps = Math.max(1, Math.round(calculatedFps))
args.push(
'-r',
calculatedFps.toString(),
'-g',
roundedFps.toString(),
'-force_key_frames',
'expr:gte(t,n_forced*1)',
)
}
}
if (!params.disableAudio) {
args.push('-map', '0:a?')
}
const encoder = await this.selectH264Encoder(params.hardwareAcceleration)
args.push('-c:v', encoder.name)
if (encoder.presetArgs.length > 0) {
args.push(...encoder.presetArgs)
}
if (params.videoBitrate) {
args.push('-b:v', params.videoBitrate)
} else {
const { maxrate, bufsize } = calculateMaxBitrate(
params.height,
params.width,
params.sourceVideoBitrate,
params.frameRate,
)
args.push('-maxrate', maxrate, '-bufsize', bufsize)
}
args.push('-pix_fmt', 'yuv420p')
if (!params.disableAudio) {
args.push('-c:a', 'aac', '-b:a', '128k')
}
if (params.threads && params.threads > 0) {
args.push('-threads', params.threads.toString())
}
args.push('-movflags', '+faststart', '-max_muxing_queue_size', '1024', params.outputFile)
if (params.signal) {
await execFileAsync('ffmpeg', ['-y', '-loglevel', 'warning', ...args], {
signal: params.signal,
})
} else {
await execFileAsync('ffmpeg', ['-y', '-loglevel', 'warning', ...args])
}
}
async transcodeImage(
inputFile: string | Buffer,
outputFile: string,
width: number,
quality: number,
heightOrOptions: number | null | TranscodeImageOptions = null,
): Promise<void> {
const height =
typeof heightOrOptions === 'object' && heightOrOptions !== null
? (heightOrOptions.height ?? null)
: heightOrOptions
let isPreview =
typeof heightOrOptions === 'object' && heightOrOptions !== null
? (heightOrOptions.isPreview ?? false)
: false
// Backward compatibility shim for legacy queued tasks or old call signatures passing width 480 or height 0
if (width === 480 || height === 0) {
isPreview = true
}
let input: string | Buffer = inputFile
if (typeof inputFile === 'string' && inputFile.startsWith('http')) {
const resp = await fetch(inputFile)
if (!resp.ok) {
throw new Error(`Failed to fetch image from ${inputFile}: ${resp.statusText}`)
}
input = Buffer.from(await resp.arrayBuffer())
}
const WEBP_MAX_DIMENSION = 7680
let targetW = width > 0 ? Math.min(width, WEBP_MAX_DIMENSION) : WEBP_MAX_DIMENSION
let targetH = height && height > 0 ? Math.min(height, WEBP_MAX_DIMENSION) : WEBP_MAX_DIMENSION
const sharpInstance = sharp(input, { limitInputPixels: false })
if (isPreview) {
try {
const meta = await sharpInstance.metadata()
if (meta.width && meta.height) {
// Fallback shim: If legacy 480 caller passed width=480, map targetShort to 300
const targetShort = width === 480 ? 300 : width
const maxLong = Math.round((targetShort * 16) / 9)
const dims = calculatePreviewDimensions(meta.width, meta.height, targetShort, maxLong)
targetW = dims.width
targetH = dims.height
}
} catch {
// Fallback to targetW/targetH as calculated above
}
}
// WEBP_MAX_DIMENSION (7680) safety cap is ALWAYS enforced
targetW = Math.min(targetW, WEBP_MAX_DIMENSION)
targetH = Math.min(targetH, WEBP_MAX_DIMENSION)
if (isPsdInput(input)) {
let psdPath: string
let tempDirToCleanup: string | null = null
if (typeof input === 'string') {
psdPath = input
} else {
tempDirToCleanup = this.createTempDir('psd-transcode-')
psdPath = path.join(tempDirToCleanup, 'input.psd')
fs.writeFileSync(psdPath, input)
}
try {
const resizeGeometry =
targetH < WEBP_MAX_DIMENSION
? `${targetW}x${targetH}>`
: `${targetW}x${WEBP_MAX_DIMENSION}>`
await this.execImageMagick([
`${psdPath}[0]`,
'-colorspace',
'sRGB',
'-resize',
resizeGeometry,
'-quality',
quality.toString(),
outputFile,
])
return
} finally {
if (tempDirToCleanup) {
this.removeDir(tempDirToCleanup)
}
}
}
sharpInstance.toColorspace('srgb').resize(targetW, targetH, {
withoutEnlargement: true,
fit: 'inside',
})
await sharpInstance.webp({ quality }).toFile(outputFile)
}
async generateSprite(
inputFile: string,
outputSprite: string,
outputPoster: string,
duration: number,
signal?: AbortSignal,
): Promise<void> {
const spriteFps = 100 / duration
const filterComplex = `[0:v]fps=${spriteFps},scale=w=300:h=-2,tile=10x10[sprite_out];[0:v]scale=-2:300:force_original_aspect_ratio=decrease,select='eq(n\\,0)'[thumb_out]`
const args = [
'-i',
inputFile,
'-filter_complex',
filterComplex,
'-map',
'[sprite_out]',
'-frames:v',
'1',
'-c:v',
'libwebp',
'-q:v',
'75',
outputSprite,
'-map',
'[thumb_out]',
'-c:v',
'libwebp',
'-q:v',
'75',
'-frames:v',
'1',
'-max_muxing_queue_size',
'1024',
outputPoster,
]
if (signal) {
await execFileAsync('ffmpeg', ['-y', '-loglevel', 'warning', ...args], { signal })
} else {
await execFileAsync('ffmpeg', ['-y', '-loglevel', 'warning', ...args])
}
}
async generatePdfSprite(
inputFile: string,
outputSprite: string,
outputPoster: string,
signal?: AbortSignal,
): Promise<{ pageCount: number; originalWidth: number; originalHeight: number }> {
const tmpDir = this.createTempDir('pdf-sprite-')
try {
const pagePrefix = path.join(tmpDir, 'page')
try {
if (signal) {
await execFileAsync('pdftoppm', ['-png', '-f', '1', '-l', '100', inputFile, pagePrefix], {
signal,
})
} else {
await execFileAsync('pdftoppm', ['-png', '-f', '1', '-l', '100', inputFile, pagePrefix])
}
} catch (err) {
const errCode = (err as Record<string, unknown>)?.code
const msg = err instanceof Error ? err.message : String(err)
const lower = msg.toLowerCase()
if (
errCode === 'ENOENT' ||
lower.includes('enoent') ||
(lower.includes('not found') && lower.includes('pdftoppm'))
) {
throw new Error(
`pdftoppm executable not found in $PATH. Please install poppler-utils / poppler. (${msg})`,
{ cause: err },
)
}
throw err
}
const files = fs.readdirSync(tmpDir).filter((f) => f.endsWith('.png'))
if (files.length === 0) {
throw new Error('pdftoppm produced no image outputs')
}
files.sort((a, b) => {
const numA = parseInt(a.replace(/[^0-9]/g, ''), 10)
const numB = parseInt(b.replace(/[^0-9]/g, ''), 10)
return numA - numB
})
const extractedCount = files.length
const firstPagePath = path.join(tmpDir, files[0])
const firstMeta = await sharp(firstPagePath, { limitInputPixels: false }).metadata()
const originalWidth = firstMeta.width || 800
const originalHeight = firstMeta.height || 1000
for (let f = 1; f <= 100; f++) {
const pageIdx = Math.min(extractedCount - 1, Math.floor(((f - 1) * extractedCount) / 100))
const srcPath = path.join(tmpDir, files[pageIdx])
const destPath = path.join(tmpDir, `frame_${f}.png`)
if (srcPath !== destPath) {
fs.copyFileSync(srcPath, destPath)
}
}
const spriteArgs = [
'-i',
path.join(tmpDir, 'frame_%d.png'),
'-filter_complex',
'scale=w=300:h=-2,tile=10x10',
'-frames:v',
'1',
'-c:v',
'libwebp',
'-q:v',
'75',
outputSprite,
]
if (signal) {
await execFileAsync('ffmpeg', ['-y', '-loglevel', 'warning', ...spriteArgs], { signal })
} else {
await execFileAsync('ffmpeg', ['-y', '-loglevel', 'warning', ...spriteArgs])
}
await sharp(firstPagePath, { limitInputPixels: false })
.toColorspace('srgb')
.resize(300, 533, { withoutEnlargement: true, fit: 'inside' })
.webp({ quality: 75 })
.toFile(outputPoster)
let totalPages = extractedCount
try {
const { stdout } = await execFileAsync('pdfinfo', [inputFile])
const match = stdout.match(/Pages:\s+(\d+)/)
if (match) {
totalPages = parseInt(match[1], 10)
}
} catch {
// Fallback to extracted count if pdfinfo is unavailable
}
return {
pageCount: totalPages,
originalWidth,
originalHeight,
}
} finally {
this.removeDir(tmpDir)
}
}
async getPdfInfo(inputFile: string): Promise<MediaMetadata> {
const tmpDir = this.createTempDir('pdf-info-')
let originalWidth = 800
let originalHeight = 1000
let pageCount = 1
try {
const pagePrefix = path.join(tmpDir, 'page')
await execFileAsync('pdftoppm', ['-png', '-f', '1', '-l', '1', inputFile, pagePrefix])
const files = fs.readdirSync(tmpDir).filter((f) => f.endsWith('.png'))
if (files.length > 0) {
const meta = await sharp(path.join(tmpDir, files[0]), {
limitInputPixels: false,
}).metadata()
originalWidth = meta.width || 800
originalHeight = meta.height || 1000
}
} catch (err) {
console.warn('pdftoppm not available for PDF dimensions extraction:', err)
}
try {
const { stdout } = await execFileAsync('pdfinfo', [inputFile])
const match = stdout.match(/Pages:\s+(\d+)/)
if (match) {
pageCount = parseInt(match[1], 10)
}
} catch {
// Fallback
} finally {
this.removeDir(tmpDir)
}
return {
originalWidth,
originalHeight,
duration: 0,
bitRate: 0,
frameRate: 0,
totalFrames: pageCount,
hasAudio: false,
mimeType: 'application/pdf',
}
}
async generatePdfFromText(inputFile: string, outputFile: string): Promise<void> {
const content = fs.readFileSync(inputFile, 'utf-8')
const containsCjk = /[\u3000-\u303f\u3040-\u309f\u30a0-\u30ff\u4e00-\u9fff\uac00-\ud7af]/.test(
content,
)
const cjkFont = containsCjk ? findCjkFontPath() : undefined
return new Promise<void>((resolve, reject) => {
const doc = new PDFDocument({
size: 'A4',
margin: 40,
bufferPages: true,
})
const writeStream = fs.createWriteStream(outputFile)
doc.pipe(writeStream)
if (cjkFont) {
if (cjkFont.fontName !== undefined) {
doc.font(cjkFont.fontPath, cjkFont.fontName)
} else {
doc.font(cjkFont.fontPath)
}
} else {
doc.font('Helvetica')
}
doc.fontSize(10)
doc.text(content, {
lineGap: 3,
paragraphGap: 4,
})
doc.end()
writeStream.on('finish', () => resolve())
writeStream.on('error', (err) => reject(err))
})
}
async generatePdfFromCsv(inputFile: string, outputFile: string): Promise<void> {
const content = fs.readFileSync(inputFile, 'utf-8')
const rows = parseCsvContent(content)
const containsCjk = /[\u3000-\u303f\u3040-\u309f\u30a0-\u30ff\u4e00-\u9fff\uac00-\ud7af]/.test(
content,
)
const cjkFont = containsCjk ? findCjkFontPath() : undefined
if (rows.length === 0) {
rows.push(['(Empty CSV)'])
}
const maxCols = Math.max(...rows.map((r) => r.length))
const isLandscape = maxCols > 5
return new Promise<void>((resolve, reject) => {
const doc = new PDFDocument({
size: 'A4',
layout: isLandscape ? 'landscape' : 'portrait',
margin: 30,
bufferPages: true,
})
const writeStream = fs.createWriteStream(outputFile)
doc.pipe(writeStream)
const setFont = () => {
if (cjkFont) {
if (cjkFont.fontName !== undefined) {
doc.font(cjkFont.fontPath, cjkFont.fontName)
} else {
doc.font(cjkFont.fontPath)
}
} else {
doc.font('Helvetica')
}
doc.fontSize(9)
}
setFont()
const pageWidth = doc.page.width - doc.page.margins.left - doc.page.margins.right
const colWidth = Math.max(40, pageWidth / maxCols)
const startX = doc.page.margins.left
let startY = doc.page.margins.top
const rowHeight = 20
const drawRow = (row: string[], isHeader: boolean, y: number) => {
if (isHeader) {
doc.rect(startX, y, colWidth * maxCols, rowHeight).fill('#e0e0e0')
doc.fillColor('#000000')
}
for (let col = 0; col < maxCols; col++) {
const text = row[col] || ''
const x = startX + col * colWidth
doc.rect(x, y, colWidth, rowHeight).stroke('#cccccc')
doc.fillColor('#000000').text(text, x + 4, y + 5, {
width: colWidth - 8,
height: rowHeight - 6,
ellipsis: true,
})
}
}
const headerRow = rows[0]
drawRow(headerRow, true, startY)
startY += rowHeight
for (let r = 1; r < rows.length; r++) {
if (startY + rowHeight > doc.page.height - doc.page.margins.bottom) {
doc.addPage()
setFont()
startY = doc.page.margins.top
drawRow(headerRow, true, startY)
startY += rowHeight
}
drawRow(rows[r], false, startY)
startY += rowHeight
}
doc.end()
writeStream.on('finish', () => resolve())
writeStream.on('error', (err) => reject(err))
})
}
async extractAudio(inputFile: string, outputFile: string, bitrate: string): Promise<void> {
const args = ['-i', inputFile, '-vn', '-acodec', 'libmp3lame', '-b:a', bitrate, outputFile]
await execFileAsync('ffmpeg', ['-y', '-loglevel', 'warning', ...args])
}
async getAudioInfo(inputFile: string): Promise<MediaMetadata> {
const { stdout } = await execFileAsync('ffprobe', [
'-v',
'quiet',
'-print_format',
'json',
'-show_format',
'-show_streams',
inputFile,
])
const info = JSON.parse(stdout)
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const audioStream = info.streams.find((s: any) => s.codec_type === 'audio')
if (!audioStream) {
throw new Error('No audio stream found')
}
const duration = parseFloat(info.format.duration)
return {
originalWidth: 0,
originalHeight: 0,
duration: isNaN(duration) ? 0 : duration,
bitRate: parseFloat(info.format.bit_rate) || 0,
frameRate: 0,
totalFrames: 0,
startTimecode: undefined,
hasAudio: true,
videoCodec: undefined,
audioCodec: this.resolveCodecName(audioStream),
audioChannels: audioStream?.channels,
audioSampleRate: this.safeParseInt(audioStream?.sample_rate),
audioBitDepth:
this.safeParseInt(audioStream?.bits_per_raw_sample) ??
this.safeParseInt(audioStream?.bits_per_sample),
mimeType: '',
}
}
async transcodeAudio(params: {
inputFile: string
outputFile: string
bitrate?: string
threads?: number
signal?: AbortSignal
}): Promise<void> {
const bitrate = params.bitrate || '128k'
const args = ['-i', params.inputFile, '-vn', '-c:a', 'aac', '-b:a', bitrate, '-ac', '2']
if (params.threads && params.threads > 0) {
args.push('-threads', params.threads.toString())
}
args.push(params.outputFile)
if (params.signal) {
await execFileAsync('ffmpeg', ['-y', '-loglevel', 'warning', ...args], {
signal: params.signal,
})
} else {
await execFileAsync('ffmpeg', ['-y', '-loglevel', 'warning', ...args])
}
}
async extractVideoFrames(params: ExtractVideoFramesParams): Promise<string[]> {
if (params.isImage) {
const outputFile = path.join(params.outputDir, '1.webp')
await this.transcodeImage(params.inputFile, outputFile, -1, 80, params.frameHeight)
return [outputFile]
}
const meta = await this.getVideoInfo(params.inputFile)
const isRemote =
params.inputFile.startsWith('http://') || params.inputFile.startsWith('https://')
const duration = meta.duration > 0 ? meta.duration : 1
const numFrames = Math.max(1, params.numFrames)
const step = duration / numFrames
const timestamps = Array.from({ length: numFrames }, (_, i) => i * step)
await mapConcurrent(timestamps, 10, async (t, idx) => {
const outputFile = path.join(params.outputDir, `${idx + 1}.webp`)
const args = [
...(isRemote
? ['-reconnect', '1', '-reconnect_streamed', '1', '-reconnect_delay_max', '5']
: []),
'-ss',
t.toFixed(4),
'-i',
params.inputFile,
'-vframes',
'1',
'-vf',
`scale=-2:${params.frameHeight}`,
'-c:v',
'libwebp',
'-q:v',
'80',
outputFile,
]
await execFileAsync('ffmpeg', ['-y', '-loglevel', 'warning', ...args])
})
const files = fs.readdirSync(params.outputDir)
return files
.filter((f) => f.endsWith('.webp'))
.sort((a, b) => {
const na = parseInt(path.basename(a, '.webp'))
const nb = parseInt(path.basename(b, '.webp'))
return na - nb
})
.map((f) => path.join(params.outputDir, f))
}
createTempDir(prefix: string): string {
return fs.mkdtempSync(path.join(os.tmpdir(), prefix))
}
removeDir(dir: string): void {
fs.rmSync(dir, { recursive: true, force: true })
}
// --- Task Creation Helpers ---
async createVideoTranscodeTask(assetId: string, projectId: string, spec: PrismaJson.TaskSpec) {
return this.prismaClient.workflowTask.create({
data: {
assetId,
projectId,
type: WorkflowTaskType.transcode_video,
status: WorkflowTaskStatus.pending,
payload: {
projectId,
transcode: spec,
},
},
})
}
async createImageTranscodeTask(assetId: string, projectId: string, spec: PrismaJson.TaskSpec) {
return this.prismaClient.workflowTask.create({
data: {
assetId,
projectId,
type: WorkflowTaskType.transcode_image,
status: WorkflowTaskStatus.pending,
payload: {
projectId,
transcode: spec,
},
},
})
}
async takeScreenshots(params: {
assetKey: string
assetId: string
start: number
end: number
count: number
commentTimestamp?: number | null
annotations?: PrismaJson.AnnotationList | null
signal?: AbortSignal
}): Promise<Array<{ key: string; timestamp: number }>> {
const bucket = process.env.S3_BUCKET || 'shumai'
const tmpDir = this.createTempDir('screenshot-')
try {
// 1. Resolve input source (presigned GET URL for S3/R2, local file path for local storage)
const inputSource = await s3Service.resolveInput(bucket, params.assetKey)
const isRemote = inputSource.startsWith('http://') || inputSource.startsWith('https://')
// 2. Generate timestamps
let timestamps: number[] = []
if (params.count <= 1) {
timestamps = [params.start]
} else {
const step = (params.end - params.start) / params.count
timestamps = Array.from({ length: params.count }, (_, i) => params.start + i * step)
}
// 3. Snap closest timestamp to commentTimestamp if within range (with 100ms tolerance)
const commentTimestamp = params.commentTimestamp
const EPSILON = 0.1
if (commentTimestamp !== undefined && commentTimestamp !== null) {
const inRange =
commentTimestamp >= params.start - EPSILON && commentTimestamp <= params.end + EPSILON
if (inRange) {
let closestIdx = 0
let minDiff = Math.abs(timestamps[0] - commentTimestamp)
for (let i = 1; i < timestamps.length; i++) {
const diff = Math.abs(timestamps[i] - commentTimestamp)
if (diff < minDiff) {
minDiff = diff
closestIdx = i
}
}
timestamps[closestIdx] = commentTimestamp
}
}
// 4. Extract screenshots concurrently with a limit of 10 parallel processes
const results = await mapConcurrent(timestamps, 10, async (t) => {
const outName = `shot-${t.toFixed(4)}-${ulid()}.webp`
const localShotPath = path.join(tmpDir, outName)
const args = [
...(isRemote
? ['-reconnect', '1', '-reconnect_streamed', '1', '-reconnect_delay_max', '5']
: []),
'-ss',
t.toFixed(4),
'-i',
inputSource,
'-vframes',
'1',
'-vf',
'scale=-2:720',
'-c:v',
'libwebp',
'-q:v',
'80',
localShotPath,
]
if (params.signal) {
await execFileAsync('ffmpeg', ['-y', '-loglevel', 'warning', ...args], {
signal: params.signal,
})
} else {
await execFileAsync('ffmpeg', ['-y', '-loglevel', 'warning', ...args])
}
const isMatch =
commentTimestamp !== undefined &&
commentTimestamp !== null &&
Math.abs(t - commentTimestamp) <= 1e-3
// 5. Overlay annotations if timestamp matches commentTimestamp (within float tolerance)
if (isMatch && params.annotations && params.annotations.length > 0) {
const shotBuffer = fs.readFileSync(localShotPath)
const composited = await this.overlayAnnotationsOnBuffer(shotBuffer, params.annotations)
fs.writeFileSync(localShotPath, composited)
}
// 6. Upload to S3
const assetDir = getDerivedArtifactDirectory(params.assetKey, params.assetId)
const s3Key = `${assetDir}/screenshots/${outName}`
const fileBuffer = fs.readFileSync(localShotPath)
await s3Service.putObject(bucket, s3Key, fileBuffer, fileBuffer.length, 'image/webp')
return { key: s3Key, timestamp: t }
})
return results
} finally {
this.removeDir(tmpDir)
}
}
async renderPdfPages(params: {
assetKey: string
assetId: string
start: number
end: number
commentTimestamp?: number | null
annotations?: PrismaJson.AnnotationList | null
signal?: AbortSignal
}): Promise<Array<{ key: string; page: number }>> {
const bucket = process.env.S3_BUCKET || 'shumai'
const tmpDir = this.createTempDir('pdf-pages-')
const pdfPath = path.join(tmpDir, path.basename(params.assetKey))
try {
// 1. Download PDF file
await s3Service.downloadToFile(bucket, params.assetKey, pdfPath)
// 2. Render pages via pdftoppm (-png -f start -l end)
const pagePrefix = path.join(tmpDir, 'page')
try {
const pdftoppmArgs = [
'-png',
'-f',
params.start.toString(),
'-l',
params.end.toString(),
pdfPath,
pagePrefix,
]
if (params.signal) {
await execFileAsync('pdftoppm', pdftoppmArgs, { signal: params.signal })
} else {
await execFileAsync('pdftoppm', pdftoppmArgs)
}
} catch (err) {
const errCode = (err as Record<string, unknown>)?.code
const msg = err instanceof Error ? err.message : String(err)
const lower = msg.toLowerCase()
if (
errCode === 'ENOENT' ||
lower.includes('enoent') ||
(lower.includes('not found') && lower.includes('pdftoppm'))
) {
throw new Error(
`pdftoppm executable not found in $PATH. Please install poppler-utils / poppler. (${msg})`,
{ cause: err },
)
}
throw err
}
const files = fs.readdirSync(tmpDir).filter((f) => f.endsWith('.png'))
if (files.length === 0) {
throw new Error('pdftoppm produced no image outputs')
}
files.sort((a, b) => {
const numA = parseInt(a.replace(/[^0-9]/g, ''), 10)
const numB = parseInt(b.replace(/[^0-9]/g, ''), 10)
return numA - numB
})
const results: Array<{ key: string; page: number }> = []
const stem = stemFromKey(params.assetKey)
for (let i = 0; i < files.length; i++) {
const pageNum = params.start + i
const localPngPath = path.join(tmpDir, files[i])
const webpName = `${stem}-page-${pageNum}-${ulid()}.webp`
let webpBuffer: Buffer = await sharp(localPngPath, { limitInputPixels: false })
.toColorspace('srgb')
.resize(1920, 1080, { fit: 'inside', withoutEnlargement: false })
.webp({ quality: 85 })
.toBuffer()
// Overlay annotations if comment page matches pageNum
const commentPage =
params.commentTimestamp !== undefined && params.commentTimestamp !== null
? Math.round(params.commentTimestamp)
: null
if (
commentPage !== null &&
pageNum === commentPage &&
params.annotations &&
params.annotations.length > 0
) {
webpBuffer = await this.overlayAnnotationsOnBuffer(webpBuffer, params.annotations)
}
// Upload to S3 directly from buffer
const assetDir = getDerivedArtifactDirectory(params.assetKey, params.assetId)
const s3Key = `${assetDir}/pdf_pages/${webpName}`
await s3Service.putObject(bucket, s3Key, webpBuffer, webpBuffer.length, 'image/webp')
results.push({ key: s3Key, page: pageNum })
}
return results
} finally {
this.removeDir(tmpDir)
}
}
async overlayAnnotationsOnBuffer(
imageBuffer: Buffer,
annotations: PrismaJson.AnnotationList,
): Promise<Buffer> {
if (!annotations || annotations.length === 0) {
return imageBuffer
}
const meta = await sharp(imageBuffer, { limitInputPixels: false }).metadata()
const width = meta.width || 1920
const height = meta.height || 1080
const svgStr = renderAnnotationsToSvg(width, height, annotations)
return await sharp(imageBuffer, { limitInputPixels: false })
.composite([{ input: Buffer.from(svgStr), top: 0, left: 0 }])
.toColorspace('srgb')
.resize(16383, 16383, { fit: 'inside', withoutEnlargement: true })
.webp({ quality: 85 })
.toBuffer()
}
async overlayAnnotations(params: {
assetKey: string
assetId: string
annotations: PrismaJson.AnnotationList
}): Promise<string> {
const bucket = process.env.S3_BUCKET || 'shumai'
const outName = `annotation-${ulid()}.webp`
const tmpDir = this.createTempDir('annotation-')
const imgPath = path.join(tmpDir, path.basename(params.assetKey))
try {
// 1. Download image
await s3Service.downloadToFile(bucket, params.assetKey, imgPath)
const inputBuffer = fs.readFileSync(imgPath)
// 2. Overlay annotations in memory using helper method
const compositedBuffer = await this.overlayAnnotationsOnBuffer(
inputBuffer,
params.annotations,
)
// 3. Upload to S3
const assetDir = getDerivedArtifactDirectory(params.assetKey, params.assetId)
const s3Key = `${assetDir}/annotations/${outName}`
await s3Service.putObject(
bucket,
s3Key,
compositedBuffer,
compositedBuffer.length,
'image/webp',
)
return s3Key
} finally {
this.removeDir(tmpDir)
}
}
/**
* Renders an SVG string to a PNG buffer. Used by the watermark workflow to
* rasterize the overlay before compositing it onto images or feeding it to
* ffmpeg for video overlays.
*/
async renderSvgToPng(svgString: string): Promise<Buffer> {
return sharp(Buffer.from(svgString)).png().toBuffer()
}
/**
* Downscales an image buffer to a bounded size and normalizes it to PNG.
* Used for watermark block images embedded into the SVG overlay, so large
* logo assets don't balloon the SVG/base64 payload.
*/
async downscaleImageToPng(
buffer: Buffer,
maxDimension: number,
): Promise<{ buffer: Buffer; width: number; height: number }> {
const processed = await sharp(buffer, { limitInputPixels: false })
.resize(maxDimension, maxDimension, { fit: 'inside', withoutEnlargement: true })
.png()
.toBuffer()
const meta = await sharp(processed).metadata()
return {
buffer: processed,
width: meta.width || 100,
height: meta.height || 100,
}
}
/**
* Composites an overlay PNG onto an image file and writes a WebP file.
* Used by the watermark workflow to produce watermarked image proxies.
*/
async compositeOverlayToWebpFile(
inputPath: string,
overlayPngBuffer: Buffer,
outputPath: string,
width: number,
height: number,
): Promise<void> {
await sharp(inputPath, { limitInputPixels: false })
.toColorspace('srgb')
.resize(width, height, { fit: 'inside' })
.composite([{ input: overlayPngBuffer }])
.webp({ quality: 90 })
.toFile(outputPath)
}
}
function renderAnnotationsToSvg(
width: number,
height: number,
annotations: PrismaJson.AnnotationList,
): string {
const strokeWidth = Math.max(2, Math.round(Math.max(width, height) * 0.004))
const svgElements: string[] = []
for (const ann of annotations) {
const color = ann.color || '#ff0000'
const type = ann.type
switch (type) {
case 'box': {
if (ann.points.length < 2) continue
const [start, end] = ann.points
const x = Math.min(start[0], end[0]) * width
const y = Math.min(start[1], end[1]) * height
const boxWidth = Math.abs(end[0] - start[0]) * width
const boxHeight = Math.abs(end[1] - start[1]) * height
svgElements.push(
`<rect x="${x}" y="${y}" width="${boxWidth}" height="${boxHeight}" stroke="${color}" stroke-width="${strokeWidth}" fill="none" />`,
)
break
}
case 'line':
case 'freehand': {
if (ann.points.length < 2) continue
const pointsStr = ann.points.map(([px, py]) => `${px * width},${py * height}`).join(' ')
svgElements.push(
`<polyline points="${pointsStr}" stroke="${color}" stroke-width="${strokeWidth}" stroke-linecap="round" stroke-linejoin="round" fill="none" />`,
)
break
}
case 'arrow': {
if (ann.points.length < 2) continue
const pts = ann.points.map(([px, py]) => [px * width, py * height])
const pointsStr = pts.map(([x, y]) => `${x},${y}`).join(' ')
svgElements.push(
`<polyline points="${pointsStr}" stroke="${color}" stroke-width="${strokeWidth}" stroke-linecap="round" stroke-linejoin="round" fill="none" />`,
)
const endPt = pts[pts.length - 1]
const prevPt = pts[pts.length - 2]
const dx = endPt[0] - prevPt[0]
const dy = endPt[1] - prevPt[1]
const angle = Math.atan2(dy, dx)
const pointerLength = Math.max(12, Math.max(width, height) * 0.015)
const x1 = endPt[0] - pointerLength * Math.cos(angle - Math.PI / 6)
const y1 = endPt[1] - pointerLength * Math.sin(angle - Math.PI / 6)
const x2 = endPt[0] - pointerLength * Math.cos(angle + Math.PI / 6)
const y2 = endPt[1] - pointerLength * Math.sin(angle + Math.PI / 6)
svgElements.push(
`<polygon points="${endPt[0]},${endPt[1]} ${x1},${y1} ${x2},${y2}" fill="${color}" />`,
)
break
}
}
}
return `<svg width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" xmlns="http://www.w3.org/2000/svg">${svgElements.join(
'\n',
)}</svg>`
}
export const transcodeService = new TranscodeService()