PRINTFILM: AI short-video marketing and AI short-drama creation platform
/** 漫剧画布资产生视频队列:入队即提交 Seedance Worker,刷新后可从资产状态恢复 */
import { dramaApi, type DramaAsset } from '../api/drama'
import type { VideoGenerationOptions } from './dramaVideoGenerationOptions'
import { syncAssetVideoJobToUnified } from './dramaGenQueue'
export type DramaVideoGenStatus = 'queued' | 'running' | 'done' | 'failed'
export type DramaVideoGenJob = {
id: string
projectId: number
assetId: number
assetName: string
prompt: string
options: Partial<VideoGenerationOptions>
referenceAssetIds: number[]
status: DramaVideoGenStatus
error?: string
createdAt: number
finishedAt?: number
}
type EnqueueInput = {
projectId: number
assetId: number
assetName?: string
prompt: string
options?: Partial<VideoGenerationOptions>
referenceAssetIds?: number[]
/** 仅恢复轮询(后端已在 generating,不再重复 POST) */
resumeOnly?: boolean
}
type InternalJob = DramaVideoGenJob & {
resumeOnly: boolean
resolve: (asset: DramaAsset) => void
reject: (err: Error) => void
}
/*
* MAX_POLL_CONCURRENT 同时轮询路数
* POLL_TIMEOUT_MS Seedance 等待上限
*/
const MAX_POLL_CONCURRENT = 4
const DONE_RETENTION_MS = 45_000
const POLL_INTERVAL_MS = 3000
const POLL_TIMEOUT_MS = 15 * 60 * 1000
const VIDEO_URL_RE = /\.(mp4|webm|mov)(\?|$)/i
let jobs: InternalJob[] = []
const EMPTY_SNAPSHOT: DramaVideoGenJob[] = []
let cachedSnapshot: DramaVideoGenJob[] = EMPTY_SNAPSHOT
const listeners = new Set<() => void>()
let pollingCount = 0
let pumping = false
const waitingPoll: InternalJob[] = []
// 将内部 job 转为对外结构
function toPublicJob(job: InternalJob): DramaVideoGenJob {
return {
id: job.id,
projectId: job.projectId,
assetId: job.assetId,
assetName: job.assetName,
prompt: job.prompt,
options: job.options,
referenceAssetIds: job.referenceAssetIds,
status: job.status,
error: job.error,
createdAt: job.createdAt,
finishedAt: job.finishedAt,
}
}
// 两个快照内容是否一致
function snapshotsEqual(a: DramaVideoGenJob[], b: DramaVideoGenJob[]): boolean {
if (a === b) return true
if (a.length !== b.length) return false
for (let i = 0; i < a.length; i += 1) {
const left = a[i]
const right = b[i]
if (
left.id !== right.id ||
left.status !== right.status ||
left.error !== right.error ||
left.finishedAt !== right.finishedAt
) {
return false
}
}
return true
}
// 清理过期完成项
function pruneFinished() {
const now = Date.now()
jobs = jobs.filter((job) => {
if (job.status === 'queued' || job.status === 'running') return true
if (!job.finishedAt) return true
return now - job.finishedAt < DONE_RETENTION_MS
})
}
// 重建并缓存对外快照
function refreshSnapshot() {
pruneFinished()
const next = jobs.length === 0 ? EMPTY_SNAPSHOT : jobs.map((job) => toPublicJob(job))
if (!snapshotsEqual(cachedSnapshot, next)) {
cachedSnapshot = next
}
}
// 通知订阅者,并同步到统一生成队列
function emit() {
refreshSnapshot()
listeners.forEach((listener) => listener())
for (const job of jobs) {
if (job.status === 'queued' || job.status === 'running' || job.finishedAt) {
syncAssetVideoJobToUnified({
assetId: job.assetId,
projectId: job.projectId,
assetName: job.assetName,
status: job.status,
error: job.error,
})
}
}
}
// 某资产是否正在生视频
export function isDramaAssetVideoBusy(assetId: number): boolean {
return jobs.some(
(job) =>
job.assetId === assetId && (job.status === 'queued' || job.status === 'running'),
)
}
// 读取资产 generation 状态
function readGenerationStatus(asset: DramaAsset): string {
const gen = (asset.params || {}).generation as { status?: string } | undefined
return String(gen?.status || '')
}
// 成片 URL 是否已是视频文件
function isVideoMediaUrl(url: string | null | undefined): boolean {
return Boolean(url && VIDEO_URL_RE.test(url))
}
/** 瞬时断连 / 后端热重载导致的 Failed to fetch,轮询时应重试而非判失败 */
function isTransientFetchError(err: unknown): boolean {
const msg = err instanceof Error ? err.message : String(err || '')
return /failed to fetch|networkerror|load failed|connection reset|连接被重置|网络/i.test(msg)
}
// 轮询直到资产生视频结束(必须等到 mp4,不能把旧封面图当完成)
async function waitForAssetVideo(projectId: number, assetId: number): Promise<DramaAsset> {
const started = Date.now()
let transientStreak = 0
while (Date.now() - started < POLL_TIMEOUT_MS) {
try {
const list = await dramaApi.listAssets(projectId)
transientStreak = 0
const latest = list.find((a) => a.id === assetId)
if (!latest) throw new Error('资产不存在')
const status = readGenerationStatus(latest)
if (status === 'failed') {
const gen = (latest.params || {}).generation as { error?: string } | undefined
throw new Error(String(gen?.error || '生视频失败'))
}
if (status === 'done' && latest.url) {
return latest
}
if (status !== 'generating' && status !== 'queued' && isVideoMediaUrl(latest.url)) {
return latest
}
} catch (err) {
if (isTransientFetchError(err) && transientStreak < 8) {
transientStreak += 1
await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS))
continue
}
throw err
}
await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS))
}
throw new Error('生视频超时,请刷新后重试')
}
// 有限并发轮询后端结果
async function pollJob(job: InternalJob) {
pollingCount += 1
try {
const asset = await waitForAssetVideo(job.projectId, job.assetId)
job.status = 'done'
job.finishedAt = Date.now()
emit()
job.resolve(asset)
} catch (err) {
const message = err instanceof Error ? err.message : '生视频失败'
job.status = 'failed'
job.error = message
job.finishedAt = Date.now()
emit()
job.reject(err instanceof Error ? err : new Error(message))
} finally {
pollingCount -= 1
pump()
emit()
}
}
// 调度轮询槽位
function pump() {
if (pumping) return
pumping = true
queueMicrotask(() => {
pumping = false
while (pollingCount < MAX_POLL_CONCURRENT && waitingPoll.length > 0) {
const next = waitingPoll.shift()
if (!next) break
if (next.status === 'failed' || next.status === 'done') continue
void pollJob(next)
}
emit()
})
}
// 提交后端后进入轮询
function startJob(job: InternalJob) {
void (async () => {
try {
if (!job.resumeOnly) {
await dramaApi.generateVideo({
project_id: job.projectId,
asset_id: job.assetId,
prompt: job.prompt,
model_id: job.options.model_id,
aspect_ratio: job.options.aspect_ratio,
resolution: job.options.resolution,
duration_sec: job.options.duration_sec,
image_style_id: job.options.image_style_id,
reference_asset_ids: job.referenceAssetIds,
})
}
job.status = 'running'
emit()
waitingPoll.push(job)
pump()
} catch (err) {
const message = err instanceof Error ? err.message : '生视频失败'
job.status = 'failed'
job.error = message
job.finishedAt = Date.now()
emit()
job.reject(err instanceof Error ? err : new Error(message))
}
})()
}
// 生成本地任务 id
function makeJobId() {
return `vid-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
}
/**
* 将画布资产生视频加入队列:立刻 POST 到后端 Worker,再本地轮询结果。
* 同资产已在排队/生成中时复用同一 Promise。
*/
export function enqueueDramaVideoGen(input: EnqueueInput): Promise<DramaAsset> {
const existing = jobs.find(
(job) =>
job.assetId === input.assetId &&
(job.status === 'queued' || job.status === 'running'),
)
if (existing) {
return new Promise((resolve, reject) => {
const prevResolve = existing.resolve
const prevReject = existing.reject
existing.resolve = (asset) => {
prevResolve(asset)
resolve(asset)
}
existing.reject = (err) => {
prevReject(err)
reject(err)
}
})
}
return new Promise<DramaAsset>((resolve, reject) => {
const job: InternalJob = {
id: makeJobId(),
projectId: input.projectId,
assetId: input.assetId,
assetName: (input.assetName || '').trim() || `视频 ${input.assetId}`,
prompt: input.prompt,
options: input.options || {},
referenceAssetIds: input.referenceAssetIds || [],
status: 'queued',
createdAt: Date.now(),
resumeOnly: Boolean(input.resumeOnly),
resolve,
reject,
}
jobs = [...jobs, job]
emit()
startJob(job)
})
}
/**
* 从资产列表恢复「后端仍在 generating」的视频任务。
*/
export function resumeDramaVideoGensFromAssets(
projectId: number,
assets: DramaAsset[],
onAssetUpdate?: (asset: DramaAsset) => void,
): void {
for (const asset of assets) {
if (asset.project_id !== projectId) continue
if ((asset.type || '').toLowerCase() !== 'video') continue
const status = readGenerationStatus(asset)
if (status !== 'generating' && status !== 'queued') continue
// enqueue 会复用在途轮询;重新进入画布也需要接上完成结果。
void enqueueDramaVideoGen({
projectId,
assetId: asset.id,
assetName: asset.name || undefined,
prompt: '',
resumeOnly: true,
}).then((latest) => {
// 旧任务完成后的微任务不能覆盖刚开始的下一次生成。
if (!isDramaAssetVideoBusy(asset.id)) onAssetUpdate?.(latest)
}).catch(() => {
/* 面板会显示失败 */
})
}
}