New Kids On The Function Block¶
During its main entry point function, each AEIO plug-in must fill in an AEIO_FunctionBlock, providing pointers to the functions After Effects will call for different file-related tasks.
The table below shows which functions are needed for input, and which ones are needed for output. For a bare-bones implementation, start with the functions that are noted as “Required” in the right column. You can often invoke “best-case” behavior by having After Effects handle the call for you (by returning AEIO_Err_USE_DFLT_CALLBACK
).
For a barebones AEIO for video input only, implement the following functions: AEIO_InitInSpecFromFile
or AEIO_InitInSpecInteractive
(depending on whether the source is a file or interactively generated), AEIO_DisposeInSpec
, AEIO_GetInSpecInfo
, AEIO_DrawSparseFrame
, AEIO_CloseSourceFiles
, and AEIO_InqNextFrameTime
(using AEIO_Err_USE_DFLT_CALLBACK
is fine).
Starting from the IO sample, it is best to leave the other functions defined too, and fill them in further as needed.
AEIO_FunctionBlock4¶
Function |
Response |
I or O? |
Required? |
---|---|---|---|
|
Given a file path, describe its contents to After Effects in the provided The file path is a NULL-terminated UTF-16 string with platform separators. AEIO_InitInSpecFromFile(
AEIO_BasicData *basic_dataP,
const A_UTF16Char *file_pathZ,
AEIO_InSpecH inH);
|
Input |
Yes, for file-based media |
|
Using some form of user interaction (and not a file path provided by After Effects), describe the audio and video your generated AEIO_InSpecH contains. AEIO_InitInSpecInteractive(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH inH);
|
Input |
Yes, for interactiv ely generated media |
|
Free an AEIO_DisposeInSpec(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH inH);
|
Input |
Yes |
|
For the given AEIO_FlattenOptions(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH inH,
AEIO_Handle *flat_optionsPH);
|
Input |
No |
|
For the given AEIO_InflateOptions(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH inH,
AEIO_Handle flat_optionsH);
|
Input |
No |
|
AEIO_SynchInSpec(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH inH,
A_Boolean *changed0);
|
Input |
No |
|
AEIO_GetActiveExtent(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH inH,
const A_Time *tr,
A_LRect *extent);
|
Input |
Yes |
|
Provide a few strings in AEIO_GetInSpecInfo(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH inH,
AEIO_Verbiage *verbiageP);
This function gets called OFTEN; every time we refresh the project panel.
Keep allocations to a minimum.
In the AEIOs that ship with After Effects, we check for a valid This is important; if your AEIO handles still images, this function will get called for the folder containing the stills. Hopefully, there won’t be an optionsH associated with it (unless you’re writing a truly bizarre AEIO). |
Input |
Yes |
|
Draw a frame from the AEIO_DrawSparseFrame(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH inH,
AEIO_Quality qual,
const AEIO_RationalScale *rs0,
const A_Time *tr,
const A_Time *duration0,
const A_Rect *required_region0,
PF_EffectWorld *wP,
A_long* originx,
A_long* originy,
AEIO_DrawingFlags *draw_flagsP);
NOTE: return data as linear light (1.0), and After Effects will perform any necessary transformations to bring the footage into the working colorspace. |
Input |
Yes |
|
AEIO_Err_USE_DFLT_CALLBACK allowed. Provide the dimensions (and, if necessary, scaling factor) of the video in the AEIO_InSpecH. AEIO_GetDimensions(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH inH,
const AEIO_RationalScale *rs0,
A_long *width0,
A_long *height0);
|
Input |
No |
|
AEIO_GetDuration(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH inH,
A_Time *trP);
|
Input |
No |
|
AEIO_GetTime(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH inH,
A_Time *tr);
Here are the values we use internally for common timebases: 29.97 fps: scale = 100; value= 2997; 59.94 fps: scale = 50; value = 2997; 23.976 fps: scale = 125; value = 2997; 30 fps: scale = 1; value = 30; 25 fps: scale = 1; value = 25; |
Input |
No |
|
AEIO_GetSound(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH inH,
AEIO_SndQuality quality,
const AEIO_InterruptFuncs *interrupt_funcsP0,
const A_Time *startPT,
const A_Time *durPT,
A_u_long start_sampLu,
A_u_long num_samplesLu,
void *dataPV);
|
Input |
No |
|
AEIO_InqNextFrameTime(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH inH,
const A_Time *base_time_tr,
AEIO_TimeDir time_dir,
A_Boolean *found0,
A_Time *key_time_tr0);
|
Input |
Yes |
|
AEIO_InitOutputSpec(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH,
A_Boolean *user_interacted);
NOTE: The first time your AEIO is used, After Effects caches the last-known-good optionsH in its preferences. When testing this function, delete your preferences often. |
Output |
Yes |
|
Describe (in an AEIO_GetFlatOutputOptions(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH,
AEIO_Handle *optionsH);
|
Output |
Yes |
|
AEIO_DisposeOutputOptions(
AEIO_BasicData *basic_dataP,
void *optionsPV);
|
Output |
No |
|
Display an output settings dialog (select TIFF output within After Effects to see when this dialog will occur).
Store this information in an options handle using AEIO_UserOptionsDialog(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH,
PF_EffectWorld *sample0,
A_Boolean *interacted0);
|
Output |
No |
|
Describe (in text) the output options in an AEIO_GetOutputInfo(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH,
AEIO_Verbiage *verbiage);
|
||
|
Update the AEIO_OutputInfoChanged(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH);
|
Output |
No |
|
The file path is a NULL-terminated UTF-16 string with platform separators. AEIO_SetOutputFile(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH,
A_UTF16Char *file_pathZ);
|
Output |
Yes |
|
Prepare to add frames to the output file. This is a good time to create the ouput file(s) on disk, and to write any header information to such files. This is also your first opportunity to allocate pixel buffers based on valid output spec values. AEIO_StartAdding(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH,
A_long flags);
|
Output |
Yes, for writing formats that support multiple frames |
|
Add frame(s) to output file. You may pass a pointer to a function you want called if the user interrupts the render. AEIO_AddFrame(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH,
A_long frame_index,
A_long frames,
PF_EffectWorld *wP,
const A_LPoint *origin0,
A_Boolean was_compressedB,
AEIO_InterruptFuncs *inter0);
|
Output |
Yes, for writing formats that support multiple frames |
|
Perform any clean-up associated with adding frames. AEIO_EndAdding(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH,
A_long flags);
|
Output |
Yes, for writing formats that support multiple frames |
|
Output a single frame. AEIO_OutputFrame(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH,
PF_EffectWorld *wP);
|
Output |
Yes, for writing formats that support a single frame |
|
AEIO_WriteLabels(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH,
AEIO_LabelFlags *written);
|
Output |
Yes |
|
AEIO_GetSizes(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH,
A_u_longlong *free_space,
A_u_longlong *file_size);
|
Output |
Yes |
|
Destroy any options or user data associated with the AEIO_Flush(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH);
|
||
|
Add the given sound to the output file. AEIO_AddSoundChunk(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH,
const A_Time *start,
AEIO_SndWorldH swH);
|
Output |
Yes, for writing formats with audio |
|
Optional. Do something with idle time. AEIO_Idle(
AEIO_BasicData *basic_dataP,
AEIO_ModuleSignature sig,
AEIO_IdleFlags *idle_flags0);
|
Output |
No |
|
Set AEIO_GetDepths(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH,
AEIO_OptionsFlags *which);
|
Output |
Yes |
|
AEIO_GetOutputSuffix(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH,
A_char *suffix);
|
Output |
Yes |
|
Display a footage options dialog, and indicate whether the user made any changes. AEIO_SeqOptionsDlg(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH inH,
A_Boolean *interactedPB);
|
Input |
No |
|
Enumerate the auxiliary (beyond red, green, blue and alpha) channels of data contained in an AEIO_GetNumAuxChannels(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH inH,
A_long *num_channelsPL);
|
Input |
No |
|
Describe the data type, name, channel, and dimensionality of an auxiliary data channel. AEIO_GetAuxChannelDesc(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH inH,
long chan_indexL,
PF_ChannelDesc *descP);
|
Input |
No |
|
Draw the auxiliary channel(s) from an AEIO_DrawAuxChannel(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH inH,
A_long chan_indexL,
const AEIO_DrawFramePB *pbP,
PF_ChannelChunk *chunkP);
|
||
|
Free data associated with an auxiliary channel. AEIO_FreeAuxChannel(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH inH,
PF_ChannelChunk *chunkP);
|
Input |
No |
|
Enumerate the files needed to render the given AEIO_NumAuxFiles(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH seqH,
A_long *files_per_framePL);
|
Input |
No |
|
Retrieve data from the nth auxiliary file, for the specified frame.
The path is a handle to a NULL-terminated A_UTF16Char string, and must be disposed with AEIO_GetNthAuxFileSpec(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH seqH,
A_long frame_numL,
A_long n,
AEGP_MemHandle *pathPH);
|
Input |
No, if no aux files |
|
Close (or open, depending upon closeB) the source files for an AEIO_CloseSourceFiles(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH seqH,
A_Boolean closeB);
|
Input |
Yes |
|
Enumerate the units of user data associated with the AEIO_CountUserData(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH inH,
A_u_long typeLu,
A_u_long max_sizeLu,
A_u_long *num_of_typePLu);
|
||
|
Set user data (of the given index and type) for the given AEIO_SetUserData(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH,
A_u_long typeLu,
A_u_long indexLu,
const AEIO_Handle dataH);
|
Output |
No |
|
Describe the user data (at the index and of the type given) associated with the AEIO_GetUserData(
AEIO_BasicData *basic_dataP,
AEIO_InSpecH inH,
A_u_long typeLu,
A_u_long indexLu,
A_u_long max_sizeLu,
AEIO_Handle *dataPH);
|
Input |
No |
|
Associate a marker of the specified type, at the specified frame, with the AEIO_AddMarker(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH,
A_long frame_index,
AEIO_MarkerType marker_type,
void *marker_dataPV,
AEIO_InterruptFuncs *inter0);
|
Output |
No |
|
Indicate (by setting importablePB) whether or not the plug-in can import the file.
Note that After Effects has already done basic extension checking; you may wish to open the file and determine whether or not it’s valid.
This can be a time-consuming process; most AEIOs that ship with After Effects simply return TRUE,
and deal with bad files during The file path is a NULL-terminated UTF-16 string with platform separators. AEIO_VerifyFileImportable(
AEIO_BasicData *basic_dataP,
AEIO_ModuleSignature sig,
const A_UTF16Char *file_pathZ,
A_Boolean *importablePB);
|
Input |
No |
|
Display an audio options dialog. AEIO_UserAudioOptionsDialog(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH,
A_Boolean *interacted0);
|
Output |
No |
|
Add a marker, with a flag specifying whether or not this is a composition marker. AEIO_AddMarker3(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH,
A_long frame_index,
AEGP_ConstMarkerValP marker_valP,
AEIO_RenderMarkerFlag marker_flag,
AEIO_InterruptFuncs *inter0);
|
Output |
No |
|
Describe the output mime type. This is used for XMP support. AEIO_GetMimeType(
AEIO_BasicData *basic_dataP,
AEIO_OutSpecH outH,
A_long mime_type_sizeL,
char *mime_typeZ);
|
Output |
No |
What Goes In¶
These functions manage an input specification, After Effects’ internal representation of data gathered from any source.
Any image or audio data in After Effects (except solids) is obtained from an input specification handle, or AEIO_InSpecH
.
AEGP_IOInSuite5¶
Function |
Purpose |
---|---|
|
Retrieves the options data (created by your AEIO) for the given AEGP_GetInSpecOptionsHandle(
AEIO_InSpecH inH,
void **optionsPPV);
|
|
Sets the options data for the given AEGP_SetInSpecOptionsHandle(
AEIO_InSpecH inH,
void *optionsPV,
void **old_optionsPPV);
|
|
Retrieves the file path for the AEGP_GetInSpecFilePath(
AEIO_InSpecH inH,
AEGP_MemHandle *file_nameZ);
|
|
Retrieves the frame rate of the AEGP_GetInSpecNativeFPS(
AEIO_InSpecH inH,
A_Fixed *native_fpsP);
|
|
Sets the frame rate of the AEGP_SetInSpecNativeFPS(
AEIO_InSpecH inH,
A_Fixed native_fpsP);
|
|
Retrieves the bit depth of the image data in the AEGP_GetInSpecDepth(
AEIO_InSpecH inH,
A_short *depthPS);
|
|
Indicates to After Effects the bit depth of the image data in the AEGP_SetInSpecDepth(
AEIO_InSpecH inH,
A_short depthS);
|
|
Retrieves the size (in bytes) of the data referenced by the AEGP_GetInSpecSize(
AEIO_InSpecH inH,
AEIO_FileSize *sizePLLu);
|
|
Indicates to After Effects the size (in bytes) of the data referenced by the AEGP_SetInSpecSize(
AEIO_InSpecH inH,
AEIO_FileSize sizeL);
|
|
Retrieves field information for the AEGP_GetInSpecInterlaceLabel(
AEIO_InSpecH inH,
FIEL_Label *interlaceP);
|
|
Specifies field information for the AEGP_SetInSpecInterlaceLabel(
AEIO_InSpecH inH,
const FIEL_Label *interlaceP);
|
|
Retrieves alpha channel interpretation information for the AEGP_GetInSpecAlphaLabel(
AEIO_InSpecH inH,
AEIO_AlphaLabel *alphaP);
|
|
Sets alpha channel interpretation information for the AEGP_SetInSpecAlphaLabel(
AEIO_InSpecH inH,
const AEIO_AlphaLabel* alphaP);
|
|
Retrieves the duration of the AEGP_GetInSpecDuration(
AEIO_InSpecH inH,
A_Time *durationP);
|
|
Sets the duration of the NOTE: As of 5.5, this must be called, even for frame-based file formats.
If you don’t set the This will be fixed in future versions. AEGP_SetInSpecDuration(
AEIO_InSpecH inH,
const A_Time *durationP);
|
|
Retrieves the width and height of the image data in the AEGP_GetInSpecDimensions(
AEIO_InSpecH inH,
A_long *widthPL0,
A_long *heightPL0);
|
|
Indicates to After Effects the width and height of the image data in the AEGP_SetInSpecDimensions(
AEIO_InSpecH inH,
A_long widthL,
A_long heightL);
|
|
Retrieves the width, height, bounding rect, and scaling factor applied to an AEGP_InSpecGetRationalDimensions(
AEIO_InSpecH inH,
const AEIO_RationalScale *rs0,
A_long *width0,
A_long *height0,
A_Rect *r0);
|
|
Retrieves the horizontal scaling factor applied to an AEGP_GetInSpecHSF(
AEIO_InSpecH inH,
A_Ratio *hsf);
|
|
Sets the horizontal scaling factor of an AEGP_SetInSpecHSF(
AEIO_InSpecH inH,
const A_Ratio *hsf);
|
|
Obtains the sampling rate (in samples per second) for the audio data referenced by the AEGP_GetInSpecSoundRate(
AEIO_InSpecH inH,
A_FpLong *ratePF);
|
|
Sets the sampling rate (in samples per second) for the audio data referenced by the AEGP_SetInSpecSoundRate(
AEIO_InSpecH inH,
A_FpLong rateF);
|
|
Obtains the encoding method (signed PCM, unsigned PCM, or floating point) from an AEIO_InSpecH. AEGP_GetInSpecSoundEncoding(
AEIO_InSpecH inH,
AEIO_SndEncoding *encodingP);
|
|
Sets the encoding method of an AEIO_InSpecH. AEGP_SetInSpecSoundEncoding(
AEIO_InSpecH inH,
AEIO_SndEncoding encoding);
|
|
Retrieves the bytes-per-sample (1,2, or 4) from an AEGP_GetInSpecSoundSampleSize(
AEIO_InSpecH inH,
AEIO_SndSampleSize *bytes_per_smpP);
|
|
Set the bytes per sample of an AEGP_SetInSpecSoundSampleSize(
AEIO_InSpecH inH,
AEIO_SndSampleSize bytes_per_sample);
|
|
Determines whether the audio in the AEGP_GetInSpecSoundChannels(
AEIO_InSpecH inH,
AEIO_SndChannels *num_channelsP);
|
|
Sets the audio in an AEGP_SetInSpecSoundChannels(
AEIO_InSpecH inH,
AEIO_SndChannels num_channels);
|
|
If your file format has auxiliary files which you want to prevent users from opening directly, pass it’s extension, file type and creator to this function to keep it from appearing in input dialogs. AEGP_AddAuxExtMap(
const A_char *extension,
A_long file_type,
A_long creator);
|
|
In case of RGB data, if there is an embedded icc profile, build an In case of non-RGB data, if there is an embedded non-RGB icc profile or you know the color space the data is in, set the color profile set to NULL, and provide the description as a NULL-terminated unicode string. Doing this disables color management UI that allows user to affect profile choice in the application UI. If you are unpacking non-RGB data directly into working space (to get working space use If you are unpacking non-RGB data into specific RGB color space, you must pass the profile describing this space to Either color profile or profile description should be NULL in this function. You cannot use both. AEGP_SetInSpecEmbeddedColorProfile(
AEIO_InSpecH inH,
AEGP_ConstColorProfileP color_profileP0,
const A_UTF16Char *profile_descP0);
|
|
Assign a valid RGB color profile to the footage. AEGP_SetInSpecAssignedColorProfile(
AEIO_InSpecH inH,
AEGP_ConstColorProfileP color_profileP);
|
|
New in CC. Retrieves the native start time of the footage. AEGP_GetInSpecNativeStartTime(
AEIO_InSpecH inH,
A_Time *startTimeP);
|
|
New in CC. Assign a native start time to the footage. AEGP_SetInSpecNativeStartTime(
AEIO_InSpecH inH,
const A_Time *startTimeP);
|
|
New in CC. Clear the native start time of the footage.
Setting the native start time to 0 using AEGP_ClearInSpecNativeStartTime(
AEIO_InSpecH inH);
|
|
New in CC. Retrieve the drop-frame setting of the footage. AEGP_GetInSpecNativeDisplayDropFrame(
AEIO_InSpecH inH,
A_Boolean *displayDropFrameBP);
|
|
New in CC. Assign the drop-frame setting of the footage. AEGP_SetInSpecNativeDisplayDropFrame(
AEIO_InSpecH inH,
A_Boolean displayDropFrameB);
|
What Goes Out¶
These functions manage all interactions with an output specification in After Effects’ render queue.
AEGPIOOutSuite4¶
Function |
Purpose |
---|---|
|
Retrieves the Options for the AEGP_GetOutSpecOptionsHandle(
AEIO_OutSpecH outH,
void **optionsPPV);
|
|
Sets the Options for the AEGP_SetOutSpecOptionsHandle(
AEIO_OutSpecH outH,
void *optionsPV,
void **old_optionsPPV);
|
|
Obtains the path for the If AEGP_GetOutSpecFilePath(
AEIO_OutSpecH outH,
AEGP_MemHandle *unicode_pathPH,
A_Boolean *file_rsrvdPB);
|
|
Obtains the frames per second of the AEGP_GetOutSpecFPS(
AEIO_OutSpecH outH,
A_Fixed *native_fpsP);
|
|
Sets the frames per second of the AEGP_SetOutSpecNativeFPS(
AEIO_OutSpecH outH,
A_Fixed native_fpsP);
|
|
Obtains the pixel bit depth of the AEGP_GetOutSpecDepth(
AEIO_OutSpecH outH,
A_short *depthPS);
|
|
Sets the pixel bit depth of the AEGP_SetOutSpecDepth(
AEIO_OutSpecH outH,
A_short depthPS);
|
|
Obtains field information for the AEGP_GetOutSpecInterlaceLabel(
AEIO_OutSpecH outH,
FIEL_Label *interlaceP);
|
|
Set the field information for the AEGP_SetOutSpecInterlaceLabel(
AEIO_OutSpecH outH,
const FIEL_Label *interlaceP);
|
|
Obtains alpha interpretation information for the AEGP_GetOutSpecAlphaLabel(
AEIO_OutSpecH outH,
AEIO_AlphaLabel *alphaP);
|
|
Sets the alpha interpretation for the AEGP_SetOutSpecAlphaLabel(
AEIO_OutSpecH outH,
const AEIO_AlphaLabel *alphaP);
|
|
Obtains the duration of the AEGP_GetOutSpecDuration(
AEIO_OutSpecH outH,
A_Time *durationP);
|
|
Sets the duration of the AEGP_SetOutSpecDuration(
AEIO_OutSpecH outH,
const A_Time *durationP);
|
|
Obtains the dimensions of the AEGP_GetOutSpecDimensions(
AEIO_OutSpecH outH,
A_long *widthPL0,
A_long *heightPL0);
|
|
Obtains the horizontal scaling factor of the AEGP_GetOutSpecHSF(
AEIO_OutSpecH outH,
A_Ratio *hsf);
|
|
Sets the horizontal scaling factor of the AEGP_SetOutSpecHSF(
AEIO_OutSpecH outH,
const A_Ratio *hsf);
|
|
Obtains the sampling rate for the AEGP_GetOutSpecSoundRate(
AEIO_OutSpecH outH,
A_FpLong *ratePF);
|
|
Sets the sampling rate for the AEGP_SetOutSpecSoundRate(
AEIO_OutSpecH outH,
A_FpLong rateF);
|
|
Obtains the sound encoding format of the AEGP_GetOutSpecSoundEncoding(
AEIO_OutSpecH outH,
AEIO_SndEncoding *encodingP);
|
|
Sets the sound encoding format of the AEGP_SetOutSpecSoundEncoding(
AEIO_OutSpecH outH,
AEIO_SndEncoding encoding);
|
|
Obtains the bytes-per-sample of the AEGP_GetOutSpecSoundSampleSize(
AEIO_OutSpecH outH,
AEIO_SndSampleSize *bpsP);
|
|
Sets the bytes-per-sample of the AEGP_SetOutSpecSoundSampleSize(
AEIO_OutSpecH outH,
AEIO_SndSampleSize bpsP);
|
|
Obtains the number of sounds channels in the AEGP_GetOutSpecSoundChannels(
AEIO_OutSpecH outH,
AEIO_SndChannels *channelsP);
|
|
Sets the number of sounds channels in the AEGP_SetOutSpecSoundChannels(
AEIO_OutSpecH outH,
AEIO_SndChannels channels);
|
|
Determines whether the AEGP_GetOutSpecIsStill(
AEIO_OutSpecH outH,
A_Boolean *is_stillPB);
|
|
Obtains the time of the AEGP_GetOutSpecPosterTime(
AEIO_OutSpecH outH,
A_Time *poster_timeP);
|
|
Obtains the time of the first frame in the AEGP_GetOutSpecStartFrame(
AEIO_OutSpecH outH,
A_long *start_frameP);
|
|
Obtains the pulldown phase of the AEGP_GetOutSpecPullDown(
AEIO_OutSpecH outH,
AEIO_Pulldown *pulldownP);
|
|
Passes back TRUE if there is no AEGP_GetOutSpecIsMissing(
AEIO_OutSpecH outH,
A_Boolean *missingPB);
|
|
Returns TRUE if the AEIO should embed a color profile in the output. AEGP_GetOutSpecShouldEmbedICCProfile(
AEIO_OutSpecH outH,
A_Boolean *embedPB);
|
|
Returns an (opaque) ICC color profile for embedding in the AEIO’s output.
Must be disposed with AEGP_GetNewOutSpecColorProfile(
AEGP_PluginID aegp_plugin_id,
AEIO_OutSpecH outH,
AEGP_ColorProfileP *color_profilePP);
|
|
Returns the AEGP_GetOutSpecOutputModule(
AEIO_OutSpecH outH,
AEGP_RQItemRefH *rq_itemP,
AEGP_OutputModuleRefH *om_refP);
|