Olive
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
Public Attributes | List of all members
ComposeSequenceParams Struct Reference

The ComposeSequenceParams struct. More...

#include <renderfunctions.h>

Public Attributes

Viewerviewer
 Reference to the Viewer class that's calling compose_sequence() More...
 
QOpenGLContext * ctx
 The OpenGL context to use while rendering. More...
 
Sequenceseq
 The sequence to compose. More...
 
QVector< Clip * > nests
 Array to store the nested sequence hierarchy. More...
 
bool video
 Set compose mode to video or audio. More...
 
Effectgizmos
 Set to the Effect whose gizmos were chosen to be drawn on screen. More...
 
bool texture_failed
 A variable that compose_sequence() will set to TRUE if any of the clips couldn't be shown. More...
 
bool wait_for_mutexes
 Run all cachers in the same thread that compose_sequence() is in. More...
 
int playback_speed
 Set the current playback speed (adjusted with Shuttle Left/Right) More...
 
QOpenGLShaderProgram * blend_mode_program
 Blending mode shader. More...
 
QOpenGLShaderProgram * premultiply_program
 Premultiply alpha shader. More...
 
GLuint main_buffer
 The OpenGL framebuffer object that the final texture to be shown is rendered to. More...
 
GLuint main_attachment
 The attachment to the framebuffer in main_buffer. More...
 
GLuint backend_buffer1
 Backend OpenGL framebuffer 1 used for further processing before rendering to main_buffer. More...
 
GLuint backend_attachment1
 Backend OpenGL framebuffer 1's texture attachment. More...
 
GLuint backend_buffer2
 Backend OpenGL framebuffer 2 used for further processing before rendering to main_buffer. More...
 
GLuint backend_attachment2
 Backend OpenGL framebuffer 2's texture attachment. More...
 
QOpenGLShaderProgram * ocio_shader
 OpenGL shader containing OpenColorIO shader information. More...
 
GLuint ocio_lut_texture
 OpenGL texture containing LUT obtained form OpenColorIO. More...
 

Detailed Description

The ComposeSequenceParams struct.

Struct sent to the compose_sequence() function.

Member Data Documentation

GLuint ComposeSequenceParams::backend_attachment1

Backend OpenGL framebuffer 1's texture attachment.

The texture that ComposeSequenceParams::backend_buffer1 renders to. Bound and drawn to ComposeSequenceParams::backend_buffer2 to "ping-pong" between them and various shaders.

GLuint ComposeSequenceParams::backend_attachment2

Backend OpenGL framebuffer 2's texture attachment.

The texture that ComposeSequenceParams::backend_buffer2 renders to. Bound and drawn to ComposeSequenceParams::backend_buffer1 to "ping-pong" between them and various shaders.

GLuint ComposeSequenceParams::backend_buffer1

Backend OpenGL framebuffer 1 used for further processing before rendering to main_buffer.

In some situations, compose_sequence() will do some processing through shaders that requires "ping-ponging" between framebuffers. backend_buffer1 and backend_buffer2 are used for this purpose.

GLuint ComposeSequenceParams::backend_buffer2

Backend OpenGL framebuffer 2 used for further processing before rendering to main_buffer.

In some situations, compose_sequence() will do some processing through shaders that requires "ping-ponging" between framebuffers. backend_buffer1 and backend_buffer2 are used for this purpose.

QOpenGLShaderProgram* ComposeSequenceParams::blend_mode_program

Blending mode shader.

Used only for video rendering. Never accessed with audio rendering.

A program containing the current active blending mode shader that can be bound during rendering. Must be compiled and linked beforehand. See RenderThread::blend_mode_program for how this is properly set up.

See Also
ComposeSequenceParams::video
QOpenGLContext* ComposeSequenceParams::ctx

The OpenGL context to use while rendering.

For video rendering, this must be a valid OpenGL context. For audio, this variable is never accessed.

See Also
ComposeSequenceParams::video
Effect* ComposeSequenceParams::gizmos

Set to the Effect whose gizmos were chosen to be drawn on screen.

The currently active Effect that compose_sequence() will update the gizmos of.

GLuint ComposeSequenceParams::main_attachment

The attachment to the framebuffer in main_buffer.

Used only for video rendering. Never accessed with audio rendering.

The OpenGL texture attached to the framebuffer referenced by main_buffer.

GLuint ComposeSequenceParams::main_buffer

The OpenGL framebuffer object that the final texture to be shown is rendered to.

Used only for video rendering. Never accessed with audio rendering.

When compose_sequence() is rendering the final image, this framebuffer will be bound.

QVector<Clip*> ComposeSequenceParams::nests

Array to store the nested sequence hierarchy.

Should be left empty. This array gets passed around compose_sequence() as it calls itself recursively to handle nested sequences.

GLuint ComposeSequenceParams::ocio_lut_texture

OpenGL texture containing LUT obtained form OpenColorIO.

QOpenGLShaderProgram* ComposeSequenceParams::ocio_shader

OpenGL shader containing OpenColorIO shader information.

int ComposeSequenceParams::playback_speed

Set the current playback speed (adjusted with Shuttle Left/Right)

Only used for audio rendering to determine how many samples to skip in order to play audio at the correct speed.

See Also
ComposeSequenceParams::video
QOpenGLShaderProgram* ComposeSequenceParams::premultiply_program

Premultiply alpha shader.

Used only for video rendering. Never accessed with audio rendering.

compose_sequence()'s internal composition expects premultipled alpha, but it will pre-emptively multiply any footage that is not set as already premultiplied (see Footage::alpha_is_premultiplied) using this shader. Must be compiled and linked beforehand. See RenderThread::premultiply_program for how this is properly set up.

Sequence* ComposeSequenceParams::seq

The sequence to compose.

In addition to clips, sequences also contain the playhead position so compose_sequence() knows which frame to render.

bool ComposeSequenceParams::texture_failed

A variable that compose_sequence() will set to TRUE if any of the clips couldn't be shown.

A footage item or shader may not be ready at the time this frame is drawn. If compose_sequence() couldn't draw any of the clips in the scene, this variable is set to TRUE indicating that the image rendered is a "best effort", but not the actual image.

This variable should be checked after compose_sequence() and a repaint should be triggered if it's TRUE.

Note
This variable is probably bad design and is a relic of an earlier rendering backend. There may be a better way to communicate this information.

Additionally, since compose_sequence() for video will now always run in a separate thread anyway, there's no real issue with stalling it to wait for footage to complete opening or whatever may be lagging behind. A possible side effect of this though is that the preview may become less responsive if it's stuck trying to render one frame. With the current system, the preview may show incomplete frames occasionally but at least it will show something. This may be preferable. See ComposeSequenceParams::single_threaded for a similar function that could be removed.

bool ComposeSequenceParams::video

Set compose mode to video or audio.

TRUE if this function should render video, FALSE if this function should render audio.

Viewer* ComposeSequenceParams::viewer

Reference to the Viewer class that's calling compose_sequence()

Primarily used for calling Viewer::play_wake() when appropriate.

bool ComposeSequenceParams::wait_for_mutexes

Run all cachers in the same thread that compose_sequence() is in.

Standard behavior is that all clips cache frames in their own thread and signals are sent between compose_sequence() and the clip's cacher thread regarding which frames to display and cache without stalling the compose_sequence() thread. Setting this to TRUE will run all cachers in the same thread creating a technically more "perfect" connection between them that will also stall the compose_sequence() thread. Used when rendering as timing isn't as important as creating output frames as quickly as possible.

Note
Exporting should probably be rewritten without this. While running all the cachers in one thread makes it easier to synchronize everything, export performance could probably benefit from keeping them in separate threads and syncing up with them. See ComposeSequenceParams::texture_failed for a similar function that could be removed.

The documentation for this struct was generated from the following file: