| ADTSDecoder.cpp |
static |
1320 |
57 % |
| ADTSDecoder.h |
|
793 |
- |
| ADTSDemuxer.cpp |
|
19725 |
81 % |
| ADTSDemuxer.h |
|
4599 |
100 % |
| AsyncLogger.h |
Implementation of an asynchronous lock-free logging system. |
10851 |
23 % |
| AudibilityMonitor.h |
|
3166 |
100 % |
| AudioBufferUtils.h |
The classes in this file provide a interface that uses frames as a unit.
However, they store their offsets in samples (because it's handy for pointer
operations). Those functions can convert between the two units.
|
7484 |
95 % |
| AudioCaptureTrack.cpp |
|
3181 |
81 % |
| AudioCaptureTrack.h |
See MediaTrackGraph::CreateAudioCaptureTrack.
|
888 |
100 % |
| AudioChannelFormat.cpp |
|
430 |
100 % |
| AudioChannelFormat.h |
This file provides utilities for upmixing and downmixing channels.
The channel layouts, upmixing and downmixing are consistent with the
Web Audio spec.
Channel layouts for up to 6 channels:
mono { M }
stereo { L, R }
{ L, R, C }
quad { L, R, SL, SR }
{ L, R, C, SL, SR }
5.1 { L, R, C, LFE, SL, SR }
Only 1, 2, 4 and 6 are currently defined in Web Audio.
|
8953 |
100 % |
| AudioCompactor.cpp |
|
2208 |
0 % |
| AudioCompactor.h |
|
4472 |
0 % |
| AudioConfig.cpp |
AudioConfig::ChannelLayout
|
12265 |
46 % |
| AudioConfig.h |
|
10972 |
95 % |
| AudioConverter.cpp |
Parts derived from MythTV AudioConvert Class
Created by Jean-Yves Avenard.
Copyright (C) Bubblestuff Pty Ltd 2013
Copyright (C) foobum@gmail.com 2010
|
16697 |
43 % |
| AudioConverter.h |
|
9871 |
85 % |
| AudioDeviceInfo.cpp |
readonly attribute DOMString name; |
5193 |
90 % |
| AudioDeviceInfo.h |
|
1874 |
100 % |
| AudioGenerator.h |
|
1885 |
33 % |
| AudioInputSource.cpp |
|
11250 |
65 % |
| AudioInputSource.h |
|
5662 |
100 % |
| AudioMixer.h |
This class mixes multiple streams of audio together to output a single audio
stream.
AudioMixer::Mix is to be called repeatedly with buffers that have the same
length, sample rate, sample format and channel count. This class works with
planar buffers.
When all the tracks have been mixed, calling MixedChunk() will provide
a buffer containing the mixed audio data.
This class is not thread safe.
|
3528 |
100 % |
| AudioPacketizer.h |
This class takes arbitrary input data, and returns packets of a specific
size. In the process, it can convert audio samples from 16bit integers to
float (or vice-versa).
Input and output, as well as length units in the public interface are
interleaved frames.
Allocations of output buffer can be performed by this class. Buffers can
simply be delete-d. This is because packets are intended to be sent off to
non-gecko code using normal pointers/length pairs
Alternatively, consumers can pass in a buffer in which the output is copied.
The buffer needs to be large enough to store a packet worth of audio.
The implementation uses a circular buffer using absolute virtual indices.
|
6487 |
86 % |
| AudioRingBuffer.cpp |
RingBuffer is used to preallocate a buffer of a specific size in bytes and
then to use it for writing and reading values without requiring re-allocation
or memory moving. Note that re-allocations can happen if the length of the
buffer is explicitly set to something larger than is already allocated.
Also note that the total byte size of the buffer modulo the size of the
chosen type must be zero. The RingBuffer has been created with audio sample
values types in mind which are integer or float. However, it can be used with
any trivial type. It is _not_ thread-safe! The constructor can be called on
any thread but the reads and write must happen on the same thread, which can
be different than the construction thread.
|
20330 |
61 % |
| AudioRingBuffer.h |
AudioRingBuffer works with audio sample format float or short. The
implementation wrap around the RingBuffer thus it is not thread-safe. Reads
and writes must happen in the same thread which may be different than the
construction thread. The memory is pre-allocated in the constructor, but may
also be re-allocated on the fly should a larger length be needed. The sample
format has to be specified in order to be used.
|
3696 |
- |
| AudioSampleFormat.h |
Audio formats supported in MediaTracks and media elements.
Only one of these is supported by AudioStream, and that is determined
at compile time (roughly, FLOAT32 on desktops, S16 on mobile). Media decoders
produce that format only; queued AudioData always uses that format.
|
10272 |
63 % |
| AudioSegment.cpp |
|
10560 |
87 % |
| AudioSegment.h |
This allows compilation of nsTArray<AudioSegment> and
AutoTArray<AudioSegment> since without it, static analysis fails on the
mChunks member being a non-memmovable AutoTArray.
Note that AudioSegment(const AudioSegment&) is deleted, so this should
never come into effect.
|
18137 |
84 % |
| AudioStream.cpp |
Keep a list of frames sent to the audio engine in each DataCallback along
with the playback rate at the moment. Since the playback rate and number of
underrun frames can vary in each callback. We need to keep the whole history
in order to calculate the playback position of the audio engine correctly.
|
25217 |
86 % |
| AudioStream.h |
@param aFrames The playback position in frames of the audio engine.
@return The playback position in frames of the stream,
adjusted by playback rate changes and underrun frames.
|
13179 |
90 % |
| AudioStreamTrack.cpp |
|
5205 |
93 % |
| AudioStreamTrack.h |
AUDIOSTREAMTRACK_H_ |
2415 |
89 % |
| AudioTrack.cpp |
|
2164 |
97 % |
| AudioTrack.h |
|
1474 |
100 % |
| AudioTrackList.cpp |
|
1102 |
100 % |
| AudioTrackList.h |
|
997 |
75 % |
| AudioVerifier.h |
|
4606 |
37 % |
| autoplay |
|
|
59 % |
| BackgroundVideoDecodingPermissionObserver.cpp |
|
5169 |
96 % |
| BackgroundVideoDecodingPermissionObserver.h |
|
1397 |
- |
| BaseMediaResource.cpp |
|
5400 |
91 % |
| BaseMediaResource.h |
Create a resource, reading data from the channel. Call on main thread only.
The caller must follow up by calling resource->Open().
|
5700 |
53 % |
| BitReader.cpp |
static |
4843 |
91 % |
| BitReader.h |
|
1934 |
100 % |
| BitWriter.cpp |
|
3294 |
95 % |
| BitWriter.h |
|
1554 |
67 % |
| bridge |
|
|
100 % |
| BufferMediaResource.h |
|
2509 |
55 % |
| BufferReader.h |
|
9206 |
80 % |
| ByteWriter.h |
|
1447 |
93 % |
| CallbackThreadRegistry.cpp |
static |
2912 |
27 % |
| CallbackThreadRegistry.h |
|
1908 |
50 % |
| CanvasCaptureMediaStream.cpp |
|
6641 |
90 % |
| CanvasCaptureMediaStream.h |
The CanvasCaptureMediaStream is a MediaStream subclass that provides a video
track containing frames from a canvas. See an architectural overview below.
----------------------------------------------------------------------------
=== Main Thread === __________________________
| |
| CanvasCaptureMediaStream |
|__________________________|
|
| RequestFrame()
v
________________________
________ FrameCaptureRequested? | |
| | ------------------------> | OutputStreamDriver |
| Canvas | SetFrameCapture() | (FrameCaptureListener) |
|________| ------------------------> |________________________|
|
| SetImage() -
| AppendToTrack()
|
v
__________________________
| |
| MTG / SourceMediaTrack |
|__________________________|
----------------------------------------------------------------------------
|
4443 |
80 % |
| ChannelMediaDecoder.cpp |
static |
23072 |
90 % |
| ChannelMediaDecoder.h |
MediaResourceCallback functions |
6900 |
100 % |
| ChannelMediaResource.cpp |
|
38986 |
94 % |
| ChannelMediaResource.h |
This class is responsible for managing the suspend count and report suspend
status of channel.
|
10118 |
74 % |
| CloneableWithRangeMediaResource.cpp |
|
6023 |
85 % |
| CloneableWithRangeMediaResource.h |
|
3174 |
64 % |
| components.conf |
|
3004 |
- |
| CrossGraphPort.cpp |
CrossGraphTransmitter * |
5888 |
89 % |
| CrossGraphPort.h |
Create with MediaTrackGraph::CreateCrossGraphTransmitter()
|
3017 |
71 % |
| CubebInputStream.cpp |
static |
6566 |
79 % |
| CubebInputStream.h |
|
2974 |
100 % |
| CubebUtils.cpp |
|
36542 |
82 % |
| CubebUtils.h |
|
4671 |
100 % |
| DecoderTraits.cpp |
static |
11100 |
90 % |
| DecoderTraits.h |
|
2320 |
- |
| DeviceInputTrack.cpp |
|
25192 |
72 % |
| DeviceInputTrack.h |
|
12729 |
75 % |
| docs |
|
|
- |
| doctor |
|
|
25 % |
| DOMMediaStream.cpp |
static |
16287 |
91 % |
| DOMMediaStream.h |
DOMMediaStream is the implementation of the js-exposed MediaStream interface.
This is a thin main-thread class grouping MediaStreamTracks together.
|
8010 |
94 % |
| DriftCompensation.h |
DriftCompensator can be used to handle drift between audio and video tracks
from the MediaTrackGraph.
Drift can occur because audio is driven by a MediaTrackGraph running off an
audio callback, thus it's progressed by the clock of one the audio output
devices on the user's machine. Video on the other hand is always expressed in
wall-clock TimeStamps, i.e., it's progressed by the system clock. These
clocks will, over time, drift apart.
Do not use the DriftCompensator across multiple audio tracks, as it will
automatically record the start time of the first audio samples, and all
samples for the same audio track on the same audio clock will have to be
processed to retain accuracy.
DriftCompensator is designed to be used from two threads:
- The audio thread for notifications of audio samples.
- The video thread for compensating drift of video frames to match the audio
clock.
|
4610 |
77 % |
| driftcontrol |
|
|
22 % |
| eme |
|
|
66 % |
| encoder |
|
|
84 % |
| EncoderTraits.cpp |
|
525 |
- |
| EncoderTraits.h |
|
651 |
100 % |
| ExternalEngineStateMachine.cpp |
This class monitors the amount of crash happened for a remote engine
process. It the amount of crash of the remote process exceeds the defined
threshold, then `ShouldRecoverProcess()` will return false to indicate that
we should not keep spawning that remote process because it's too easy to
crash.
In addition, we also have another mechanism in the media format reader
(MFR) to detect crash amount of remote processes, but that would only
happen during the decoding process. The main reason to choose using this
simple monitor, instead of the mechanism in the MFR is because that
mechanism can't detect every crash happening in the remote process, such as
crash happening during initializing the remote engine, or setting the CDM
pipepline, which can happen prior to decoding.
|
57176 |
24 % |
| ExternalEngineStateMachine.h |
ExternalPlaybackEngine represents a media engine which is responsible for
decoding and playback, which are not controlled by Gecko.
|
14018 |
34 % |
| fake-cdm |
|
|
0 % |
| FileBlockCache.cpp |
|
17882 |
86 % |
| FileBlockCache.h |
|
7927 |
100 % |
| FileMediaResource.cpp |
|
6878 |
79 % |
| FileMediaResource.h |
unknown size |
4933 |
68 % |
| flac |
|
|
88 % |
| ForwardedInputTrack.cpp |
|
10245 |
96 % |
| ForwardedInputTrack.h |
See MediaTrackGraph::CreateForwardedInputTrack.
|
2480 |
50 % |
| FrameStatistics.h |
|
6706 |
95 % |
| fuzz |
|
|
- |
| GetUserMediaRequest.cpp |
|
4644 |
97 % |
| GetUserMediaRequest.h |
|
3014 |
100 % |
| gmp |
|
|
67 % |
| gmp-plugin-openh264 |
|
|
85 % |
| GraphDriver.cpp |
|
55686 |
82 % |
| GraphDriver.h |
Assume we can run an iteration of the MediaTrackGraph loop in this much time
or less.
We try to run the control loop at this rate.
|
35164 |
85 % |
| GraphRunner.cpp |
static |
5232 |
98 % |
| GraphRunner.h |
Marks us as shut down and signals mThread, so that it runs until the end.
|
3758 |
100 % |
| gtest |
|
|
0 % |
| hls |
|
|
- |
| IdpSandbox.sys.mjs |
This little class ensures that redirects maintain an https:// origin |
8272 |
96 % |
| imagecapture |
|
|
76 % |
| ImageConversion.cpp |
|
29560 |
18 % |
| ImageConversion.h |
Gets a SourceSurface from given image.
|
1960 |
- |
| Intervals.h |
Interval defines an interval between two points. Unlike a traditional
interval [A,B] where A <= x <= B, the upper boundary B is exclusive: A <= x <
B (e.g [A,B[ or [A,B) depending on where you're living) It provides basic
interval arithmetic and fuzzy edges. The type T must provides a default
constructor and +, -, <, <= and == operators.
|
20911 |
89 % |
| ipc |
|
|
45 % |
| MediaBlockCacheBase.h |
MEDIA_BLOCK_CACHE_BASE_H_ |
3158 |
100 % |
| MediaCache.cpp |
static |
105427 |
94 % |
| MediaCache.h |
|
25789 |
100 % |
| mediacapabilities |
|
|
72 % |
| MediaChannelStatistics.h |
This class is useful for estimating rates of data passing through
some channel. The idea is that activity on the channel "starts"
and "stops" over time. At certain times data passes through the
channel (usually while the channel is active; data passing through
an inactive channel is ignored). The GetRate() function computes
an estimate of the "current rate" of the channel, which is some
kind of average of the data passing through over the time the
channel is active.
All methods take "now" as a parameter so the user of this class can
control the timeline used.
|
2628 |
100 % |
| MediaContainerType.cpp |
|
998 |
80 % |
| MediaContainerType.h |
|
1674 |
100 % |
| mediacontrol |
|
|
78 % |
| MediaData.cpp |
|
28201 |
57 % |
| MediaData.h |
|
27068 |
84 % |
| MediaDataDemuxer.h |
IsExclusive = |
8562 |
85 % |
| MediaDecoder.cpp |
|
60759 |
89 % |
| MediaDecoder.h |
aIgnored |
30928 |
92 % |
| MediaDecoderOwner.h |
|
7849 |
11 % |
| MediaDecoderStateMachine.cpp |
|
177807 |
87 % |
| MediaDecoderStateMachine.h |
Each media element for a media file has one thread called the "audio thread".
The audio thread writes the decoded audio data to the audio
hardware. This is done in a separate thread to ensure that the
audio hardware gets a constant stream of data without
interruption due to decoding or display. At some point
AudioStream will be refactored to have a callback interface
where it asks for data and this thread will no longer be
needed.
The element/state machine also has a TaskQueue which runs in a
SharedThreadPool that is shared with all other elements/decoders. The state
machine dispatches tasks to this to call into the MediaDecoderReader to
request decoded audio or video data. The Reader will callback with decoded
sampled when it has them available, and the state machine places the decoded
samples into its queues for the consuming threads to pull from.
The MediaDecoderReader can choose to decode asynchronously, or synchronously
and return requested samples synchronously inside it's Request*Data()
functions via callback. Asynchronous decoding is preferred, and should be
used for any new readers.
Synchronisation of state between the thread is done via a monitor owned
by MediaDecoder.
The lifetime of the audio thread is controlled by the state machine when
it runs on the shared state machine thread. When playback needs to occur
the audio thread is created and an event dispatched to run it. The audio
thread exits when audio playback is completed or no longer required.
A/V synchronisation is handled by the state machine. It examines the audio
playback time and compares this to the next frame in the queue of video
frames. If it is time to play the video frame it is then displayed, otherwise
it schedules the state machine to run again at the time of the next frame.
Frame skipping is done in the following ways:
1) The state machine will skip all frames in the video queue whose
display time is less than the current audio time. This ensures
the correct frame for the current time is always displayed.
2) The decode tasks will stop decoding interframes and read to the
next keyframe if it determines that decoding the remaining
interframes will cause playback issues. It detects this by:
a) If the amount of audio data in the audio queue drops
below a threshold whereby audio may start to skip.
b) If the video queue drops below a threshold where it
will be decoding video data that won't be displayed due
to the decode thread dropping the frame immediately.
TODO: In future we should only do this when the Reader is decoding
synchronously.
When hardware accelerated graphics is not available, YCbCr conversion
is done on the decode task queue when video frames are decoded.
The decode task queue pushes decoded audio and videos frames into two
separate queues - one for audio and one for video. These are kept
separate to make it easy to constantly feed audio data to the audio
hardware while allowing frame skipping of video data. These queues are
threadsafe, and neither the decode, audio, or state machine should
be able to monopolize them, and cause starvation of the other threads.
Both queues are bounded by a maximum size. When this size is reached
the decode tasks will no longer request video or audio depending on the
queue that has reached the threshold. If both queues are full, no more
decode tasks will be dispatched to the decode task queue, so other
decoders will have an opportunity to run.
During playback the audio thread will be idle (via a Wait() on the
monitor) if the audio queue is empty. Otherwise it constantly pops
audio data off the queue and plays it with a blocking write to the audio
hardware (via AudioStream).
|
21220 |
100 % |
| MediaDecoderStateMachineBase.cpp |
aSupportsTailDispatch = |
7775 |
100 % |
| MediaDecoderStateMachineBase.h |
The state machine class. This manages the decoding and seeking in the
MediaDecoderReader on the decode task queue, and A/V sync on the shared
state machine thread, and controls the audio "push" thread.
All internal state is synchronised via the decoder monitor. State changes
are propagated by scheduling the state machine to run another cycle on the
shared state machine thread.
|
11949 |
80 % |
| MediaDeviceInfo.cpp |
|
1583 |
100 % |
| MediaDeviceInfo.h |
|
1573 |
100 % |
| MediaDevices.cpp |
If requestedMediaTypes is the empty set, return a promise rejected with a
TypeError. |
34152 |
91 % |
| MediaDevices.h |
|
4882 |
83 % |
| mediaelement |
|
|
90 % |
| MediaEventSource.h |
A thread-safe tool to communicate "revocation" across threads. It is used to
disconnect a listener from the event source to prevent future notifications
from coming. Revoke() can be called on any thread. However, it is recommended
to be called on the target thread to avoid race condition.
RevocableToken is not exposed to the client code directly.
Use MediaEventListener below to do the job.
|
27588 |
96 % |
| MediaFormatReader.cpp |
This class tracks shutdown promises to ensure all decoders are shut down
completely before MFR continues the rest of the shutdown procedure.
|
133153 |
91 % |
| MediaFormatReader.h |
|
34240 |
95 % |
| MediaFragmentURIParser.cpp |
|
8882 |
91 % |
| MediaFragmentURIParser.h |
|
3629 |
71 % |
| MediaInfo.cpp |
|
5969 |
29 % |
| MediaInfo.h |
|
23393 |
84 % |
| MediaManager.cpp |
Using WebRTC backend on Desktops (Mac, Windows, Linux), otherwise default |
191350 |
86 % |
| MediaManager.h |
Device info that is independent of any Window.
MediaDevices can be shared, unlike LocalMediaDevices.
|
16767 |
100 % |
| MediaMetadataManager.h |
|
3346 |
97 % |
| MediaMIMETypes.cpp |
|
8425 |
58 % |
| MediaMIMETypes.h |
|
9214 |
86 % |
| MediaPlaybackDelayPolicy.cpp |
|
5203 |
88 % |
| MediaPlaybackDelayPolicy.h |
We usaually start AudioChannelAgent when media starts and stop it when media
stops. However, when we decide to delay media playback for unvisited tab, we
would start AudioChannelAgent even if media doesn't start in order to
register the agent to AudioChannelService, so that the service could notify
us when we are able to resume media playback. Therefore,
ResumeDelayedPlaybackAgent is used to handle this special use case of
AudioChannelAgent.
- Use `GetResumePromise()` to require resume-promise and then do follow-up
resume behavior when promise is resolved.
- Use `UpdateAudibleState()` to update audible state only when media info
changes. As having audio track or not is the only thing for us to decide
whether we would show the delayed media playback icon on the tab bar.
|
2933 |
75 % |
| MediaPromiseDefs.h |
aIgnored |
470 |
- |
| MediaQueue.h |
|
10966 |
90 % |
| MediaRecorder.cpp |
MediaRecorderReporter measures memory being used by the Media Recorder.
It is a singleton reporter and the single class object lives as long as at
least one Recorder is registered. In MediaRecorder, the reporter is
unregistered when it is destroyed.
|
76776 |
87 % |
| MediaRecorder.h |
Implementation of
https://w3c.github.io/mediacapture-record/MediaRecorder.html
The MediaRecorder accepts a MediaStream as input passed from an application.
When the MediaRecorder starts, a MediaEncoder will be created and accepts the
MediaStreamTracks in the MediaStream as input source. For each track it
creates a TrackEncoder.
The MediaEncoder automatically encodes and muxes data from the tracks by the
given MIME type, then it stores this data into a MutableBlobStorage object.
When a timeslice is set and the MediaEncoder has stored enough data to fill
the timeslice, it extracts a Blob from the storage and passes it to
MediaRecorder. On RequestData() or Stop(), the MediaEncoder extracts the blob
from the storage and returns it to MediaRecorder through a MozPromise.
Thread model: When the recorder starts, it creates a worker thread (called
the encoder thread) that does all the heavy lifting - encoding, time keeping,
muxing.
|
6862 |
100 % |
| MediaResource.cpp |
|
16292 |
88 % |
| MediaResource.h |
Provides a thread-safe, seek/read interface to resources
loaded from a URI. Uses MediaCache to cache data received over
Necko's async channel API, thus resolving the mismatch between clients
that need efficient random access to the data and protocols that do not
support efficient random access, such as HTTP.
Instances of this class must be created on the main thread.
Most methods must be called on the main thread only. Read, Seek and
Tell must only be called on non-main threads. In the case of the Ogg
Decoder they are called on the Decode thread for example. You must
ensure that no threads are calling these methods once Close is called.
Instances of this class are reference counted. Use nsRefPtr for
managing the lifetime of instances of this class.
The generic implementation of this class is ChannelMediaResource, which can
handle any URI for which Necko supports AsyncOpen.
The 'file:' protocol can be implemented efficiently with direct random
access, so the FileMediaResource implementation class bypasses the cache.
For cross-process blob URL, CloneableWithRangeMediaResource is used.
MediaResource::Create automatically chooses the best implementation class.
|
13385 |
87 % |
| MediaResourceCallback.h |
A callback used by MediaResource (sub-classes like FileMediaResource,
RtspMediaResource, and ChannelMediaResource) to notify various events.
Currently this is implemented by MediaDecoder only.
Since this class has no pure virtual function, it is convenient to write
gtests for the readers without using a mock MediaResource when you don't
care about the events notified by the MediaResource.
|
2058 |
30 % |
| MediaResult.cpp |
|
1970 |
50 % |
| MediaResult.h |
|
3811 |
93 % |
| MediaSegment.h |
Track or graph rate in Hz. Maximum 1 << TRACK_RATE_MAX_BITS Hz. This
maximum avoids overflow in conversions between track rates and conversions
from seconds.
|
16330 |
77 % |
| mediasession |
|
|
87 % |
| MediaShutdownManager.cpp |
|
5953 |
69 % |
| MediaShutdownManager.h |
|
3410 |
100 % |
| mediasink |
|
|
90 % |
| mediasource |
|
|
83 % |
| MediaSpan.h |
|
4416 |
58 % |
| MediaStreamError.cpp |
|
3851 |
76 % |
| MediaStreamError.h |
|
2968 |
100 % |
| MediaStreamTrack.cpp |
MTGListener monitors state changes of the media flowing through the
MediaTrackGraph.
For changes to PrincipalHandle the following applies:
When the main thread principal for a MediaStreamTrack changes, its principal
will be set to the combination of the previous principal and the new one.
As a PrincipalHandle change later happens on the MediaTrackGraph thread, we
will be notified. If the latest principal on main thread matches the
PrincipalHandle we just saw on MTG thread, we will set the track's principal
to the new one.
We know at this point that the old principal has been flushed out and data
under it cannot leak to consumers.
In case of multiple changes to the main thread state, the track's principal
will be a combination of its old principal and all the new ones until the
latest main thread principal matches the PrincipalHandle on the MTG thread.
|
20290 |
90 % |
| MediaStreamTrack.h |
Common interface through which a MediaStreamTrack can communicate with its
producer on the main thread.
Kept alive by a strong ref in all MediaStreamTracks (original and clones)
sharing this source.
|
22310 |
96 % |
| MediaStreamWindowCapturer.cpp |
|
2515 |
81 % |
| MediaStreamWindowCapturer.h |
Given a DOMMediaStream and a window id, this class will pipe the audio from
all live audio tracks in the stream to the MediaTrackGraph's window capture
mechanism.
|
1650 |
100 % |
| MediaTimer.cpp |
static |
6380 |
96 % |
| MediaTimer.h |
We use a callback function, rather than a callback method, to ensure that
the nsITimer does not artifically keep the refcount of the MediaTimer above
zero. When the MediaTimer is destroyed, it safely cancels the nsITimer so
that we never fire against a dangling closure.
|
5327 |
94 % |
| MediaTrack.cpp |
|
1127 |
100 % |
| MediaTrack.h |
Base class of AudioTrack and VideoTrack. The AudioTrack and VideoTrack
objects represent specific tracks of a media resource. Each track has aspects
of an identifier, category, label, and language, even if a track is removed
from its corresponding track list, those aspects do not change.
When fetching the media resource, an audio/video track is created if the
media resource is found to have an audio/video track. When the UA has learned
that an audio/video track has ended, this audio/video track will be removed
from its corresponding track list.
Although AudioTrack and VideoTrack are not EventTargets, TextTrack is, and
TextTrack inherits from MediaTrack as well (or is going to).
|
2580 |
78 % |
| MediaTrackGraph.cpp |
A hash table containing the graph instances, one per Window ID,
sample rate, and device ID combination.
|
156452 |
92 % |
| MediaTrackGraph.h |
MediaTrackGraph is a framework for synchronized audio/video processing
and playback. It is designed to be used by other browser components such as
HTML media elements, media capture APIs, real-time media streaming APIs,
multitrack media APIs, and advanced audio APIs.
The MediaTrackGraph uses a dedicated thread to process media --- the media
graph thread. This ensures that we can process media through the graph
without blocking on main-thread activity. The media graph is only modified
on the media graph thread, to ensure graph changes can be processed without
interfering with media processing. All interaction with the media graph
thread is done with message passing.
APIs that modify the graph or its properties are described as "control APIs".
These APIs are asynchronous; they queue graph changes internally and
those changes are processed all-at-once by the MediaTrackGraph. The
MediaTrackGraph monitors the main thread event loop via
nsIAppShell::RunInStableState to ensure that graph changes from a single
event loop task are always processed all together. Control APIs should only
be used on the main thread, currently; we may be able to relax that later.
To allow precise synchronization of times in the control API, the
MediaTrackGraph maintains a "media timeline". Control APIs that take or
return times use that timeline. Those times never advance during
an event loop task. This time is returned by
MediaTrackGraph::GetCurrentTime().
Media decoding, audio processing and media playback use thread-safe APIs to
the media graph to ensure they can continue while the main thread is blocked.
When the graph is changed, we may need to throw out buffered data and
reprocess it. This is triggered automatically by the MediaTrackGraph.
|
52274 |
91 % |
| MediaTrackGraphImpl.h |
A per-track update message passed from the media graph thread to the
main thread.
|
45269 |
90 % |
| MediaTrackList.cpp |
|
4734 |
92 % |
| MediaTrackList.h |
Base class of AudioTrackList and VideoTrackList. The AudioTrackList and
VideoTrackList objects represent a dynamic list of zero or more audio and
video tracks respectively.
When a media element is to forget its media-resource-specific tracks, its
audio track list and video track list will be emptied.
|
3441 |
70 % |
| MediaTrackListener.cpp |
|
3425 |
84 % |
| MediaTrackListener.h |
This is a base class for media graph thread listener callbacks locked to
specific tracks. Override methods to be notified of audio or video data or
changes in track state.
All notification methods are called from the media graph thread. Overriders
of these methods are responsible for all synchronization. Beware!
These methods are called without the media graph monitor held, so
reentry into media graph methods is possible, although very much discouraged!
You should do something non-blocking and non-reentrant (e.g. dispatch an
event to some thread) and return.
The listener is not allowed to add/remove any listeners from the parent
track.
If a listener is attached to a track that has already ended, we guarantee
to call NotifyEnded.
|
7560 |
74 % |
| MemoryBlockCache.cpp |
|
8012 |
74 % |
| MemoryBlockCache.h |
MEMORY_BLOCK_CACHE_H_ |
2973 |
100 % |
| metrics.yaml |
|
31545 |
- |
| MockCubeb.cpp |
|
28028 |
40 % |
| MockCubeb.h |
|
28198 |
65 % |
| moz.build |
|
10630 |
- |
| mp3 |
|
|
92 % |
| mp4 |
|
|
81 % |
| nsIAudioDeviceInfo.idl |
|
1879 |
- |
| nsIDocumentActivity.h |
Use this macro when declaring classes that implement this interface. |
798 |
- |
| nsIMediaDevice.idl |
|
731 |
- |
| nsIMediaManager.idl |
return a array of inner windows that have active captures |
1618 |
- |
| ogg |
|
|
78 % |
| Pacer.h |
Pacer<T> takes a queue of Ts tied to timestamps, and emits PacedItemEvents
for every T at its corresponding timestamp.
The queue is ordered. Enqueing an item at time t will drop all items at times
later than T. This is because of how video sources work (some send out frames
in the future, some don't), and to allow swapping one source for another.
It supports a duplication interval. If there is no new item enqueued within
the duplication interval since the last enqueued item, the last enqueud item
is emitted again.
|
7323 |
100 % |
| PeerConnection.sys.mjs |
|
60219 |
90 % |
| PeerConnectionIdp.sys.mjs |
Creates an IdP helper.
@param win (object) the window we are working for
@param timeout (int) the timeout in milliseconds
|
11113 |
93 % |
| platforms |
|
|
48 % |
| PrincipalChangeObserver.h |
A PrincipalChangeObserver for any type, but originating from DOMMediaStream,
then expanded to MediaStreamTrack.
Used to learn about dynamic changes to an object's principal.
Operations relating to these observers must be confined to the main thread.
|
783 |
- |
| PrincipalHandle.h |
The level of privacy of a principal as considered by RTCPeerConnection.
|
1865 |
86 % |
| QueueObject.cpp |
|
827 |
0 % |
| QueueObject.h |
|
723 |
- |
| ReaderProxy.cpp |
|
8254 |
95 % |
| ReaderProxy.h |
A wrapper around MediaFormatReader to offset the timestamps of Audio/Video
samples by the start time to ensure MDSM can always assume zero start time.
It also adjusts the seek target passed to Seek() to ensure correct seek time
is passed to the underlying reader.
|
4472 |
72 % |
| SeekJob.cpp |
|
733 |
100 % |
| SeekJob.h |
SEEK_JOB_H |
742 |
100 % |
| SeekTarget.h |
SEEK_TARGET_H |
2453 |
90 % |
| SelfRef.h |
|
894 |
100 % |
| SharedBuffer.h |
Base class for objects with a thread-safe refcount and a virtual
destructor.
|
3627 |
77 % |
| systemservices |
|
|
74 % |
| test |
|
|
79 % |
| tests |
|
|
- |
| TimedPacketizer.h |
This class wraps an AudioPacketizer and provides packets of audio with
timestamps.
|
2342 |
0 % |
| TimeUnits.cpp |
|
13549 |
89 % |
| TimeUnits.h |
|
13571 |
96 % |
| tools |
|
|
- |
| Tracing.cpp |
|
2669 |
72 % |
| Tracing.h |
TRACING_H |
3738 |
62 % |
| UnboundedMPSCQueue.h |
|
5649 |
65 % |
| UnderrunHandler.h |
|
891 |
- |
| UnderrunHandlerLinux.cpp |
|
2244 |
33 % |
| UnderrunHandlerNoop.cpp |
|
381 |
33 % |
| utils |
|
|
60 % |
| VideoFrameContainer.cpp |
|
9262 |
95 % |
| VideoFrameContainer.h |
This object is used in the decoder backend threads and the main thread
to manage the "current video frame" state. This state includes timing data
and an intrinsic size (see below).
This has to be a thread-safe object since it's accessed by resource decoders
and other off-main-thread components. So we can't put this state in the media
element itself ... well, maybe we could, but it could be risky and/or
confusing.
|
6133 |
94 % |
| VideoFrameConverter.h |
An active VideoFrameConverter actively converts queued video frames.
While inactive, we keep track of the frame most recently queued for
processing, so it can be immediately sent out once activated.
|
23131 |
89 % |
| VideoLimits.h |
|
653 |
- |
| VideoOutput.h |
|
11086 |
99 % |
| VideoPlaybackQuality.cpp |
|
1252 |
100 % |
| VideoPlaybackQuality.h |
|
1477 |
100 % |
| VideoSegment.cpp |
static |
6535 |
96 % |
| VideoSegment.h |
|
6936 |
94 % |
| VideoStreamTrack.cpp |
|
2436 |
92 % |
| VideoStreamTrack.h |
Whether this VideoStreamTrack's video frames will have an alpha channel.
|
1643 |
80 % |
| VideoTrack.cpp |
|
2751 |
98 % |
| VideoTrack.h |
|
2058 |
100 % |
| VideoTrackList.cpp |
|
2717 |
68 % |
| VideoTrackList.h |
|
1273 |
80 % |
| VideoUtils.cpp |
|
41960 |
72 % |
| VideoUtils.h |
ReentrantMonitorConditionallyEnter
Enters the supplied monitor only if the conditional value |aEnter| is true.
E.g. Used to allow unmonitored read access on the decode thread,
and monitored access on all other threads.
|
20607 |
88 % |
| WavDumper.h |
If MOZ_DUMP_AUDIO is set, this dumps a file to disk containing the output of
an audio stream, in 16bits integers.
The sandbox needs to be disabled for this to work.
|
4206 |
17 % |
| wave |
|
|
87 % |
| webaudio |
|
|
89 % |
| webcodecs |
|
|
60 % |
| webm |
|
|
89 % |
| webrtc |
|
|
66 % |
| webspeech |
|
|
74 % |
| webvtt |
|
|
93 % |
| XiphExtradata.cpp |
|
2810 |
38 % |
| XiphExtradata.h |
This converts a list of headers to the canonical form of extradata for Xiph
codecs in non-Ogg containers. We use it to pass those headers from demuxer
to decoder even when demuxing from an Ogg cotainer. |
1038 |
- |