prgpu 0.1.15

GPU-accelerated rendering utilities for Adobe Premiere Pro and After Effects plugins
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

//! Static host + backend capability map.
//!
//! Effect code expresses contracts (`if !ctx.supports(Capability::FrameExpansion) { ... }`)
//! instead of `is_premiere()` / `is_after_effects()` checks scattered across the
//! codebase. Capabilities are derived from `(Host, Backend)` via fixed rules
//! the adapter layer applies on every render call.

use crate::types::Backend;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Host {
	AfterEffects,
	Premiere,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RenderKind {
	AeLegacyRender,
	AeSmartRenderCpu,
	AeSmartRenderGpu,
	PremiereGpuEffect,
	PremiereGpuTransition,
	TestCpu,
	TestGpu,
}

impl RenderKind {
	pub const fn host(self) -> Host {
		match self {
			RenderKind::AeLegacyRender | RenderKind::AeSmartRenderCpu | RenderKind::AeSmartRenderGpu => Host::AfterEffects,
			RenderKind::PremiereGpuEffect | RenderKind::PremiereGpuTransition => Host::Premiere,
			RenderKind::TestCpu | RenderKind::TestGpu => Host::AfterEffects,
		}
	}

	pub const fn is_test(self) -> bool {
		matches!(self, RenderKind::TestCpu | RenderKind::TestGpu)
	}
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Capability {
	/// Effect can request a larger output rect than the input layer (AE only).
	FrameExpansion,
	/// Host respects per-parameter UI visibility flags during interactive editing.
	DynamicParamVisibility,
	/// Host may hand the same PPix as both source and output; passes that touch
	/// source after writing the output need a private snapshot.
	SourceOutputMayAlias,
	/// Native Premiere GPU filter dispatch (`xGPUFilterEntry`) is in play.
	NativePremiereGpuFilter,
	/// Effect is being driven through After Effects' `SmartRenderGpu` selector.
	SmartRenderGpu,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct HostCapabilities {
	host: Host,
	backend: Backend,
}

impl HostCapabilities {
	pub const fn new(host: Host, backend: Backend) -> Self {
		Self { host, backend }
	}

	pub const fn host(&self) -> Host {
		self.host
	}

	pub const fn backend(&self) -> Backend {
		self.backend
	}

	pub const fn supports(&self, capability: Capability) -> bool {
		match capability {
			// Premiere has no SDK call to enlarge `outFrame` on the GPU path,
			// and Premiere CPU is disabled too for byte-for-byte parity.
			Capability::FrameExpansion => matches!(self.host, Host::AfterEffects),
			Capability::DynamicParamVisibility => true,
			Capability::SourceOutputMayAlias => matches!(self.host, Host::Premiere) && !matches!(self.backend, Backend::Cpu),
			Capability::NativePremiereGpuFilter => matches!(self.host, Host::Premiere) && !matches!(self.backend, Backend::Cpu),
			Capability::SmartRenderGpu => matches!(self.host, Host::AfterEffects) && !matches!(self.backend, Backend::Cpu),
		}
	}
}