|AndroidHardwareBufferApi provides apis for managing AHardwareBuffer.
The apis are supported since Android O(APIVersion 26).
|This utility class allows reusing code between the webrender and
non-webrender compositor-side implementations. It provides
utility functions for sampling animations at particular timestamps.
|Set a callback responsible for recycling this object
before it is finalized.
|The simulation is advanced forward in time with a fixed time step to ensure
that it remains deterministic given variable framerates. To determine the
position at any variable time, two samples are interpolated.
kFixedtimestep is set to 120hz in order to ensure that every frame in a
common 60hz refresh rate display will have at least one physics simulation
sample. More accuracy can be obtained by reducing kFixedTimestep to smaller
intervals, such as 240hz or 1000hz, at the cost of more CPU cycles. If
kFixedTimestep is increased to much longer intervals, interpolation will
become less effective at reducing temporal jitter and the simulation will
|AxisPhysicsModel encapsulates a generic 1-dimensional physically-based motion
It performs frame-rate independent interpolation and RK4 integration for
smooth animation with stable, deterministic behavior.
Implementations are expected to subclass and override the Acceleration()
|Constructs an AxisPhysicsMSDModel with initial values for state.
@param aInitialPosition sets the initial position of the simulated spring,
@param aInitialDestination sets the resting position of the simulated spring,
@param aInitialVelocity sets the initial velocity of the simulated spring,
in AppUnits / second. Critically-damped and over-damped systems are
guaranteed not to overshoot aInitialDestination if this is set to 0;
however, it is possible to overshoot and oscillate if not set to 0 or
the system is under-damped.
@param aSpringConstant sets the strength of the simulated spring. Greater
values of mSpringConstant result in a stiffer / stronger spring.
@param aDampingRatio controls the amount of dampening force and determines
if the system is under-damped, critically-damped, or over-damped.
|AxisPhysicsMSDModel encapsulates a 1-dimensional MSD (Mass-Spring-Damper)
model. A unit mass is assumed.
|Represents a layer that might have a non-rectangular geometry.
|Why not just use ifdefs?
ifdefs tend to result in code that compiles on one platform but not another.
Given the number of build and platform configurations we have, it's best to
aim to compile the same on as many platforms as possible, and let the
compiler see the constexprs and handle dead-code elision itself.
|This is the important state to make sure the other side signals or starts
us as soon as data or space is available. We set AboutToWait first and
then re-check the condition. If we went straight to Waiting or Stopped
then in between the last check and setting the state, the other side
could have used all available data or space and never have signaled us
because it didn't know we were about to wait, causing a deadlock.
While we are in this state, the other side must wait until we resolve the
AboutToWait state to one of the other states and then signal or start us
if it needs to.
|A captured frame from a |LayerManager|.
|This transform is calculated from sampleanimation in device pixel
and used for layers (i.e. non WebRender)
|Flags used by texture clients and texture hosts. These are passed from client
side to host side when textures and compositables are created. Usually set
by the compositableCient, they may be modified by either the compositable or
|Used for checking if CompositorDevice/ContentDevice is updated.
|A texture data wrapping a dcomp surface handle, which is provided by the
media foundation media engine. We won't be able to control real texture data
because that is protected by the media engine.
|Effects and effect chains are used by the compositor API (see Compositor.h).
An effect chain represents a rendering method, for example some shader and
the data required for that shader to run. An effect is some component of the
chain and its data.
An effect chain consists of a primary effect - how the 'texture' memory
should be interpreted (RGBA, BGRX, YCBCR, etc.) - and any number of secondary
- any way in which rendering can be changed, e.g., applying a mask layer.
During the rendering process, an effect chain is created by the layer being
rendered and the primary effect is added by the compositable host. Secondary
effects may be added by the layer or compositable. The effect chain is passed
to the compositor by the compositable host as a parameter to DrawQuad.
|Metrics about a scroll frame that are sent to the compositor and used
This is used for two main purposes:
(1) Sending information about a scroll frame to the compositor and APZ
as part of a layers or WebRender transaction.
(2) Storing information about a scroll frame in APZ that persists
TODO: Separate these two uses into two distinct structures.
A related class, RepaintRequest, is used for sending information about a
scroll frame back from the compositor to the main thread when requesting
a repaint of the scroll frame's contents.
|Forward declarations for Image derivatives.
|The PLANAR_YCBCR format creates a PlanarYCbCrImage. All backends should
support this format, because the Ogg video decoder depends on it.
The maximum image width and height is 16384.
|Base class for userdata objects attached to layers and layer managers.
We define it here in a separate header so clients only need to include
this header for their class definitions, rather than pulling in Layers.h.
Everything else in Layers.h should be forward-declarable.
|Extract and separate the CbCr planes
|This renderer works with WebGL running in the host process. It does
not perform any graphics operations itself -- it is the client-side
representation. It forwards WebGL composition to the remote process.
|A PersistentBufferProvider is for users which require the temporary use of
a DrawTarget to draw into. When they're done drawing they return the
DrawTarget, when they later need to continue drawing they get a DrawTarget
from the provider again, the provider will guarantee the contents of the
previously returned DrawTarget is persisted into the one newly returned.
|Can be used to submit screenshots from the compositor to the profiler.
Screenshots have a fixed bounding size. The user of this class will usually
scale down the window contents first, ideally on the GPU, then read back the
small scaled down image into main memory, and then call SubmitScreenshot to
pass the data to the profiler.
This class encodes each screenshot to a JPEG data URL, on a separate thread.
This class manages that thread and recycles memory buffers.
Users of ProfilerScreenshots should have one ProfilerScreenshot instance per
window, as a unique window id is created by the constructor.
|RemoteTextureTxnScheduler manages dependencies on transaction numbers for a
given top-level protocol ("type"). It expects that transaction numbers are
all sequenced and comparable for this top-level protocol. Dependencies may
then be issued on a given future transaction number. Clients must notify the
scheduler when transactions are completed, so that any dependencies can be
cleared as the transaction number advances. Generally, transaction numbers
will be generated by a FwdTransactionCounter on a top-level protocol child,
and there should be a RemoteTextureTxnScheduler instantiated on the top-level
protocol parent that corresponds to the same protocol lifetime as the child.
To ease sharing in sub-protocols, RemoteTextureTxnScheduler is ref-counted
and may be multiply-registered by the various sub-protocols that derive from
a given top-level protocol, without having to directly refer to the original
|When compositing frames, there is usually a "sample time" associated
with the frame, which may be derived from vsync or controlled by a test.
This class encapsulates that and tracks where the sample time comes from,
as the desired behaviour may vary based on the time source.
|The actual implementation of screenshot grabbing.
The ScreenshotGrabberImpl object is destroyed if the profiler is
disabled and MaybeGrabScreenshot notices it.
|Used by various renderers / layer managers to grab snapshots from the window
and submit them to the Gecko profiler.
Doesn't do any work if the profiler is not running or the "screenshots"
feature is not enabled.
Screenshots are scaled down to fit within a fixed size, and read back to
main memory using async readback. Scaling is done in multiple scale-by-0.5x
steps using DownscaleTarget::CopyFrom, and readback is done using
|This class allows us to uniquely identify a scrollable layer. The
mLayersId identifies the layer tree (corresponding to a child process
and/or tab) that the scrollable layer belongs to. The mPresShellId
is a temporal identifier (corresponding to the document loaded that
contains the scrollable layer, which may change over time). The
mScrollId corresponds to the actual frame that is scrollable.
|It stores data for scroll thumb layer or container layers.
|If defined, this makes SourceSurfaceSharedData::Finalize memory protect the
underlying shared buffer in the producing process (the content or UI
process). Given flushing the page table is expensive, and its utility is
predominantly diagnostic (in case of overrun), turn it off by default.
|This class is used to wrap shared (as in process) data buffers allocated by
a SourceSurfaceSharedData object. It may live in the same process or a
different process from the actual SourceSurfaceSharedData object.
If it is in the same process, mBuf is the same object as that in the surface.
It is a useful abstraction over just using the surface directly, because it
can have a different lifetime from the surface; if the surface gets freed,
consumers may continue accessing the data in the buffer. Releasing the
original surface is a signal which feeds into SharedSurfacesParent to decide
to release the SourceSurfaceSharedDataWrapper.
If it is in a different process, mBuf is a new SharedMemoryBasic object which
mapped in the given shared memory handle as read only memory.
|Allocate a unique id number for the current refresh tick, can
only be called while IsInRefresh().
If too many id's are allocated without being returned then
the refresh driver will suspend until they catch up. This
"throttling" behaviour can be skipped by passing aThrottle=false.
Otherwise call sites should generally be passing aThrottle=true.
|Returned by |aPostAction| and |aPreAction| in ForEachNode, indicates
the behavior to follow either action:
TraversalFlag::Skip - the node's children are not traversed. If this
flag is returned by |aPreAction|, |aPostAction| is skipped for the
current node, as well.
TraversalFlag::Continue - traversal continues normally.
TraversalFlag::Abort - traversal stops immediately.