||This transform is calculated from sampleanimation in device pixel
and used by compositor.
||Since HTMLCanvasElement and OffscreenCanvas are not thread-safe, we create
AsyncCanvasRenderer which is thread-safe wrapper object for communicating
among main, worker and ImageBridgeChild threads.
Each HTMLCanvasElement object is responsible for creating
AsyncCanvasRenderer object. Once Canvas is transfered to worker,
OffscreenCanvas will keep reference pointer of this object.
Sometimes main thread needs AsyncCanvasRenderer's result, such as layers
GetSurface() in main thread will readback the result to mSurface.
If layers backend is LAYERS_CLIENT, this object will pass to ImageBridgeChild
for submitting frames to Compositor.
||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.
||Initialize the write side of a CanvasEventRingBuffer returning handles to
the shared memory for the buffer and the two semaphores for waiting in the
reader and the writer.
@param aOtherPid process ID to share the handles to
@param aReadHandle handle to the shared memory for the buffer
@param aReaderSem reading blocked semaphore
@param aWriterSem writing blocked semaphore
@param aResumeReaderCallback callback to start the reader when it is has
@returns true if initialization succeeds
||Create a canvas translator for a particular TextureType, which translates
events from a CanvasEventRingBuffer.
@param aTextureType the TextureType the translator will create
@param aReadHandle handle to the shared memory for the
@param aReaderSem reading blocked semaphore for the CanvasEventRingBuffer
@param aWriterSem writing blocked semaphore for the CanvasEventRingBuffer
@returns the new CanvasTranslator
||A captured frame from a |LayerManager|.
||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
||A shared CanvasRenderer implementation that supports copying
its contents into a gfxASurface using RebackSurface.
||Used for checking if CompositorDevice/ContentDevice is updated.
||Wraps a D3D9 texture, shared with the compositor though DXGI.
At the moment it is only used with D3D11 compositing, and the corresponding
TextureHost is DXGITextureHostD3D11.
||Add a new edge to the graph.
||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.
||Helper struct to hold a couple of fields that can be updated as part of
an empty transaction.
||We need to be able to hold a reference to a Moz2D SourceSurface from Image
subclasses. This is potentially a problem since Images can be addrefed
or released off the main thread. We can ensure that we never AddRef
a SourceSurface off the main thread, but we might want to Release due
to an Image being destroyed off the main thread.
We use nsCountedRef<nsMainThreadSourceSurfaceRef> to reference the
SourceSurface. When AddRefing, we assert that we're on the main thread.
When Releasing, if we're not on the main thread, we post an event to
the main thread to do the actual release.
||A Layer which renders an Image.
||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.
||It stores data for scroll thumb layer or container layers.
||This must occur *after* layers/PLayers.h to avoid typedefs conflicts.
||Recover the z component from a 2d transformed point by finding the
intersection of a line through the point in the z direction and the
We want to solve:
point = normal . (p0 - l0) / normal . l
||Get accumulated transform of from the context creating layer to the
||Callback for ContainerLayer invalidations.
@param aContainer ContainerLayer being invalidated.
@param aRegion Invalidated region in the ContainerLayer's coordinate
space. If null, then the entire region must be invalidated.
||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
||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.
||A ReadbackSink receives a stream of updates to a rectangle of pixels.
These update callbacks are always called on the main thread, either during
EndTransaction or from the event loop.
||Called by the container before processing any child layers. Call this
if any child layer might have changed in any way (other than content-only
changes to layers other than ColorLayers and PaintedLayers).
This method recomputes the relationship between ReadbackLayers and
sibling layers, and dispatches changes to ReadbackLayers. Except that
if a PaintedLayer needs its contents sent to some ReadbackLayer, we'll
just record that internally and later the PaintedLayer should call
GetPaintedLayerUpdates when it paints, to find out which rectangle needs
to be sent, and the ReadbackLayer it needs to be sent to.
||@param aXSide LEFT means we draw from the left side of the buffer (which
is drawn on the right side of mBufferRect). RIGHT means we draw from
the right side of the buffer (which is drawn on the left side of
@param aYSide TOP means we draw from the top side of the buffer (which
is drawn on the bottom side of mBufferRect). BOTTOM means we draw from
the bottom side of the buffer (which is drawn on the top side of
||This is a cairo/Thebes surface, but with a literal twist. Scrolling
causes the layer's visible region to move. We want to keep
reusing the same surface if the region size hasn't changed, but we don't
want to keep moving the contents of the surface around in memory. So
we use a trick.
Consider just the vertical case, and suppose the buffer is H pixels
high and we're scrolling down by N pixels. Instead of copying the
buffer contents up by N pixels, we leave the buffer contents in place,
and paint content rows H to H+N-1 into rows 0 to N-1 of the buffer.
Then we can refresh the screen by painting rows N to H-1 of the buffer
at row 0 on the screen, and then painting rows 0 to N-1 of the buffer
at row H-N on the screen.
mBufferRotation.y would be N in this example.
||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.
||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.
||This class is used to wrap volatile data buffers used for source surfaces.
The Map and Unmap semantics are used to guarantee that the volatile data
buffer is not freed by the operating system while the surface is in active
use. If GetData is expected to return a non-null value without a
corresponding Map call (and verification of the result), the surface data
should be wrapped in a temporary SourceSurfaceRawData with a ScopedMap
||Can only be drawn into through Cairo.
The coresponding TextureHost depends on the compositor
||This is meant for a texture host which does a direct upload from
Updated to a Compositor specific DataTextureSource and therefor doesn't
need any specific Lock/Unlock magic.
||Stores the origin and size of a tile buffer and handles switching between
tile indices and tile coordinates.
Tile coordinates in TileCoordIntPoint take the first tile offset into account
which means that two TilesPlacement of the same layer and resolution give
tile coordinates in the same coordinate space (useful when changing the
offset and/or size of a tile buffer).
||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.