Project Overview and Workflow:
My project aims to enable users to write scripts in Python to create and manipulate custom image, video, and audio data within After Effects. The current functionality allows users to select and run scripts through a menu command, with plans to evolve this into a more interactive and GUI-based approach. It could be a global script, or it could be a simple task based script. Best way I can put it is it works nearly the same as running extendscript from file->scripts->run, and end-goal is exposing that functionality to "CEP" ("PYE") extensions as well, effectively offering an alternative to extendscript.
Technical Approach and Error Handling:
I'm working with pybind11 for Python integration and wrapping SDK functions in a Result<T, A_Err> struct for error handling. If an SDK function fails, the error is propagated up to Python, allowing for appropriate handling. Result structs are thread safe, and exposed python classes use std::shared_ptrs for memory management. I'm wrapping the entire SDK in single-concern functions like this;
```c++
Result<AEGP_ItemH> getActiveItem()
{
AEGP_SuiteHandler& suites = SuiteManager::GetInstance().GetSuiteHandler();
A_Err err = A_Err_NONE;
AEGP_ItemH itemH = nullptr; // Initialize to nullptr in case AEGP_GetActiveItem fails
ERR(suites.ItemSuite9()->AEGP_GetActiveItem(&itemH));
Result<AEGP_ItemH> result;
if (err != A_Err_NONE) {
result.value = nullptr;
throw std::runtime_error("Error getting active item. Error code: " + std::to_string(err));
}
else {
result.value = itemH;
}
result.error = err; // Set the error
return result;
}
```
Regarding the wrappers-- anything that stands out that I could be doing a bit better here for error handling?
Performance Concerns:
A primary focus is on optimizing performance, particularly regarding UI blocking, processing speed, and memory management.
I've solved the UI-blocking issue by putting python on a separate thread, and calling into the idleHook with 1:1 command calls. (Each exposed python method sends one call into the idleHook queue, which even with multiple items in the queue, will return with each call to prevent blocking.)
Python-AE Communication:
The plugin uses a thread-safe queue for communication between Python and AE, ensuring a non-blocking UI.
Frame Handling in Effect Plugins:
Here's how I envision the frame handling working out: In the effect plugin, frames are gathered and placed in a struct that includes the frame number for accurate handling in Python. They are then processed by Python and sent back. Another approach is for users to write a custom callback function, used by the effect to implement the desired effect. Here's an example in Python demonstrating this concept:
```python
from PyShiftCore import *
def some_callback_function(**args) # create a callback function
# processing pixels here
return ImageData
comp = app.project.activeItem # check for the activeItem
if isinstance(comp, CompItem): # if comp is actually a composition
layer1 = comp.layer[0] # get the first layer
layer1.customEffect(some_callback_function(**args)) # pass a custom callback function to pass into the effect, which will then be used to call into python to perform processing.
layer1.requestFrames(list[int] frameNum) #request a frame at a given time
layer1.requestAllFrames() #request all frames from the layer
layer1.replaceFrame(int frameNum, ImageData frame) #replace frame at given time
layer1.replaceAllFrames() #replace all frames in layer.
else:
app.reportInfo("Select a Composition first!") # if comp is not a CompItem, the user needs to select a comp instead.
```
Regarding your mention of AEGPs writing into the output buffer, this synchronous approach seems promising, especially considering the challenges with the Python GIL. My main objective is to streamline the transfer of pixel data into numpy arrays for extensive processing capabilities.
Future Plans and Challenges:
The long-term goal is to enable users to create custom effects, transitions, and standard manipulation through Python, eliminating the need for extensive C++ plugin development. I have established a solid foundation with numerous working classes, attributes, and methods. In the near term, I aim to finish wrapping the SDK functions, ensuring proper error and memory handling, and then flesh out PyShiftCore to match most attributes of extendscript.
Hopefully this paints a bit clearer of a picture. If there's anything that needs further clarification or if you have any specific suggestions or feedback, especially regarding workflows for the custom processing and object lifetime, please let me know!!
Thank you for your time and consideration!
9
Replies
AdChoices