Name Description Size
ADTSDecoder.cpp static 1506
ADTSDecoder.h 914
ADTSDemuxer.cpp 24590
ADTSDemuxer.h 4829
AsyncLogger.h Implementation of an asynchronous lock-free logging system. 9101
AudibilityMonitor.h 3377
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. 7420
AudioCaptureTrack.cpp 4674
AudioCaptureTrack.h See MediaTrackGraph::CreateAudioCaptureTrack. 1187
AudioChannelFormat.cpp 510
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. 9077
AudioCompactor.cpp 2329
AudioCompactor.h 4608
AudioConfig.cpp AudioConfig::ChannelLayout 10797
AudioConfig.h 9851
AudioConverter.cpp Parts derived from MythTV AudioConvert Class Created by Jean-Yves Avenard. Copyright (C) Bubblestuff Pty Ltd 2013 Copyright (C) 2010 16817
AudioConverter.h 10010
AudioDeviceInfo.cpp readonly attribute DOMString name; 5273
AudioDeviceInfo.h 1925
AudioDriftCorrection.h ClockDrift calculates the diverge of the source clock from the nominal (provided) rate compared to the target clock, which is considered the master clock. In the case of different sampling rates, it is assumed that resampling will take place so the returned correction is estimated after the resampling. That means that resampling is taken into account in the calculations but it does appear in the correction. The correction must be applied to the top of the resampling. It works by measuring the incoming, the outgoing frames, and the amount of buffered data and estimates the correction needed. The correction logic has been created with two things in mind. First, not to run out of frames because that means the audio will glitch. Second, not to change the correction very often because this will result in a change in the resampling ratio. The resampler recreates its internal memory when the ratio changes which has a performance impact. The pref `media.clock drift.buffering` can be used to configure the desired internal buffering. Right now it is at 50ms. But it can be increased if there are audio quality problems. 9032
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 interleaved and plannar buffers, but the buffer mixed must be of the same type during a mixing cycle. When all the tracks have been mixed, calling FinishMixing will call back with a buffer containing the mixed audio data. This class is not thread safe. 4599
AudioNotificationReceiver.cpp A list containing all clients subscribering the device-changed notifications. 2662
AudioNotificationReceiver.h Architecture to send/receive default device-changed notification: Chrome Process ContentProcess 1 ------------------ ------------------ AudioNotification DeviceChangeListener 1 DeviceChangeListener N | ^ | ^ ^ (4)| |(2) |(3) |(8) . v | v | v AudioNotificationSender AudioNotificationReceiver ^ | ^ ^ . (5)| |(1) |(7) . v | | . (P)ContentParent 1 (P)ContentChild 1 . | ^ . (6)| | . | | . | | . +------------------------------------+ . PContent IPC . . Content Process M . ------------------ . . v . (P)ContentParent M < . . . . . . . . . > (P)ContentChild M PContent IPC Steps -------- 1) Initailize the AudioNotificationSender when ContentParent is created. 2) Create an AudioNotification to get the device-changed signal from the system. 3) Register the DeviceChangeListener to AudioNotificationReceiver when it's created. 4) When the default device is changed, AudioNotification get the signal and 5) Pass this message by AudioNotificationSender. 6) The AudioNotificationSender sends the device-changed notification via the PContent. 7) The ContentChild will call AudioNotificationReceiver to 8) Notify all the registered audio streams to reconfigure the output devices. Notes -------- a) There is only one AudioNotificationSender and AudioNotification in a chrome process. b) There is only one AudioNotificationReceiver and might be many DeviceChangeListeners in a content process. c) There might be many ContentParent in a chrome process. d) There is only one ContentChild in a content process. e) All the DeviceChangeListeners are registered in the AudioNotificationReceiver. f) All the ContentParents are registered in the AudioNotificationSender. 4179
AudioNotificationSender.cpp A runnable task to notify the audio device-changed event. 6826
AudioNotificationSender.h 984
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. 6284
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 any re-allocation or memory moving. Please 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. 15772
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. The sample format has to be specified in order to be used. 3127
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. 6622
AudioSegment.cpp 7583
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. 16944
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. 22221
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. 11243
AudioStreamTrack.cpp 3117
AudioStreamTrack.h AUDIOSTREAMTRACK_H_ 2043
AudioThreadRegistry.h 2949
AudioTrack.cpp 2303
AudioTrack.h 1614
AudioTrackList.cpp 1207
AudioTrackList.h 1137
AutoplayPolicy.cpp 12022
AutoplayPolicy.h AutoplayPolicy is used to manage autoplay logic for all kinds of media, including MediaElement, Web Audio and Web Speech. Autoplay could be disable by setting the pref "media.autoplay.default" to anything but nsIAutoplay::Allowed. Once user disables autoplay, media could only be played if one of following conditions is true. 1) Owner document is activated by user gestures We restrict user gestures to "mouse click", "keyboard press" and "touch". 2) Muted media content or video without audio content. 3) Document's origin has the "autoplay-media" permission. 2493
BackgroundVideoDecodingPermissionObserver.cpp 5306
BackgroundVideoDecodingPermissionObserver.h 1439
BaseMediaResource.cpp 5443
BaseMediaResource.h Create a resource, reading data from the channel. Call on main thread only. The caller must follow up by calling resource->Open(). 5738
Benchmark.cpp 12622
Benchmark.h IsExclusive = 3479
BitReader.cpp static 4020
BitReader.h 1489
BitWriter.cpp 2891
BitWriter.h 1130
BufferMediaResource.h 2498
BufferReader.h 8596
ByteWriter.h 1480
CanvasCaptureMediaStream.cpp 6334
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 | |__________________________| ---------------------------------------------------------------------------- 4516
ChannelMediaDecoder.cpp static 18486
ChannelMediaDecoder.h MediaResourceCallback functions 6245
ChannelMediaResource.cpp 35356
ChannelMediaResource.h This class is responsible for managing the suspend count and report suspend status of channel. 9797
CloneableWithRangeMediaResource.cpp 6014
CloneableWithRangeMediaResource.h 3216
CrossGraphPort.cpp CrossGraphTransmitter * 6539
CrossGraphPort.h See MediaTrackGraph::CreateCrossGraphTransmitter() 3266
CubebUtils.cpp Index for failures to create an audio stream the first time. 27986
CubebUtils.h 2906
DOMMediaStream.cpp 15933
DOMMediaStream.h DOMMediaStream is the implementation of the js-exposed MediaStream interface. This is a thin main-thread class grouping MediaStreamTracks together. 8317
DecoderTraits.cpp static 11793
DecoderTraits.h 2880
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. 4763
DynamicResampler.cpp 16456
DynamicResampler.h DynamicResampler allows updating on the fly the output sample rate and the number of channels. In addition to that, it maintains an internal buffer for the input data and allows pre-buffering as well. The Resample() method strives to provide the requested number of output frames by using the input data including any pre-buffering. If this is not possible then it will not attempt to resample and it will return failure. Input data buffering makes use of the AudioRingBuffer. The capacity of the buffer is 100ms of float audio and it is pre-allocated at the constructor. No extra allocations take place when the input is appended. In addition to that, due to special feature of AudioRingBuffer, no extra copies take place when the input data is fed to the resampler. The sample format must be set before using any method. If the provided sample format is of type short the pre-allocated capacity of the input buffer becomes 200ms of short audio. The DynamicResampler is not thread-safe, so all the methods appart from the constructor must be called on the same thread. 15665
FileBlockCache.cpp 17814
FileBlockCache.h 7894
FileMediaResource.cpp 6837
FileMediaResource.h unknown size 4730
ForwardedInputTrack.cpp 10006
ForwardedInputTrack.h See MediaTrackGraph::CreateForwardedInputTrack. 2533
FrameStatistics.h 6334
GVAutoplayPermissionRequest.cpp static 8633
GVAutoplayPermissionRequest.h This class is used to provide an ability for GeckoView (GV) to allow its embedder (application) to decide whether the autoplay media should be allowed or denied on the page. We have two types of request, one for audible media, another one for inaudible media. Each page would at most have one request per type at a time, and the result of request would be effective on that page until the page gets reloaded or closed. 3608
GVAutoplayRequestStatusIPC.h 753
GVAutoplayRequestUtils.h 585
GetUserMediaRequest.cpp 2827
GetUserMediaRequest.h 1956
GraphDriver.cpp 45784
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. 32174
GraphRunner.cpp static 4444
GraphRunner.h Marks us as shut down and signals mThread, so that it runs until the end. 3858
IdpSandbox.jsm This little class ensures that redirects maintain an https:// origin 8431
ImageToI420.cpp 5353
ImageToI420.h Converts aImage to an I420 image and writes it to the given buffers. 787
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. 20628
MPSCQueue.h 5540
MediaBlockCacheBase.h MEDIA_BLOCK_CACHE_BASE_H_ 3325
MediaCache.cpp static 105428
MediaCache.h 26005
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. 2967
MediaContainerType.cpp 1119
MediaContainerType.h 1796
MediaData.cpp 18514
MediaData.h 23654
MediaDataDemuxer.h IsExclusive = 8269
MediaDecoder.cpp 45750
MediaDecoder.h aIgnored 25626
MediaDecoderOwner.h Fires a timeupdate event. If aPeriodic is true, the event will only be fired if we've not fired a timeupdate event (for any reason) in the last 250ms, as required by the spec when the current time is periodically increasing during playback. 7596
MediaDecoderStateMachine.cpp 142756
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). 28882
MediaDeviceInfo.cpp 1608
MediaDeviceInfo.h 1914
MediaDevices.cpp 8697
MediaDevices.h 2890
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. 13895
MediaFormatReader.cpp This class tracks shutdown promises to ensure all decoders are shut down completely before MFR continues the rest of the shutdown procedure. 111817
MediaFormatReader.h 27921
MediaInfo.cpp 2399
MediaInfo.h 13599
MediaMIMETypes.cpp static 9100
MediaMIMETypes.h 9089
MediaManager.cpp Using WebRTC backend on Desktops (Mac, Windows, Linux), otherwise default 182692
MediaManager.h Posts an async operation to the media manager thread. FunctionType must be a function that takes a `MozPromiseHolder&`. The returned promise is resolved or rejected by aFunction on the media manager thread. 13579
MediaMetadataManager.h 3471
MediaPlaybackDelayPolicy.cpp 5252
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. 3082
MediaPromiseDefs.h aIgnored 592
MediaQueue.h 5651
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. 74780
MediaRecorder.h Implementation of The MediaRecorder accepts a mediaStream as input source passed from UA. When recorder starts, a MediaEncoder will be created and accept the mediaStream as input source. Encoder will get the raw data by track data changes, encode it by selected MIME Type, then store the encoded in a MutableBlobStorage object. The encoded data will be extracted on every timeslice passed from Start function call or by RequestData function. Thread model: When the recorder starts, it creates a "Media Encoder" thread to read data from MediaEncoder object and store buffer in MutableBlobStorage object. Also extract the encoded data and create blobs on every timeslice passed from start function or RequestData function called by UA. 7182
MediaResource.cpp 16839
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. 13147
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. 2311
MediaResult.h 2726
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. 16267
MediaShutdownManager.cpp 5764
MediaShutdownManager.h 3571
MediaSpan.h 4577
MediaStatistics.h 3271
MediaStreamError.cpp 3024
MediaStreamError.h 3232
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. 20230
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. 20322
MediaStreamWindowCapturer.cpp 2215
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. 1555
MediaTimer.cpp 6211
MediaTimer.h IsExclusive = 5342
MediaTrack.cpp 1266
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). 2720
MediaTrackGraph.cpp A hash table containing the graph instances, one per document. The key is a hash of nsPIDOMWindowInner, see `WindowToHash`. 136904
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. 45312
MediaTrackGraphImpl.h A per-track update message passed from the media graph thread to the main thread. 37549
MediaTrackList.cpp 4655
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. 3555
MediaTrackListener.cpp 3628
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. 7681
MemoryBlockCache.cpp 8173
MemoryBlockCache.h MEMORY_BLOCK_CACHE_H_ 3128
PeerConnection.jsm jshint moz:true, browser:true 66430
PeerConnectionIdp.jsm jshint moz:true, browser:true 11185
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. 930
PrincipalHandle.h We pass the principal through the MediaTrackGraph by wrapping it in a thread safe nsMainThreadPtrHandle, since it cannot be used directly off the main thread. We can compare two PrincipalHandles to each other on any thread, but they can only be created and converted back to nsIPrincipal* on main thread. 1798
QueueObject.cpp 947
QueueObject.h 845
ReaderProxy.cpp 7559
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. 3712
SeekJob.cpp 853
SeekJob.h SEEK_JOB_H 862
SeekTarget.h SEEK_TARGET_H 2400
SelfRef.h 1015
SharedBuffer.h Base class for objects with a thread-safe refcount and a virtual destructor. 3707
TextTrack.cpp 12433
TextTrack.h 4602
TextTrackCue.cpp Save a reference to our creating document so we don't have to keep getting it from our window. 8023
TextTrackCue.h 8907
TextTrackCueList.cpp 3432
TextTrackCueList.h 2394
TextTrackList.cpp 6097
TextTrackList.h 2566
TextTrackRegion.cpp 1963
TextTrackRegion.h WebIDL Methods. 3629
ThreadPoolCOMListener.cpp 814
ThreadPoolCOMListener.h 908
TimeUnits.h 7978
Tracing.cpp 2639
Tracing.h TRACE is for use in the real-time audio rendering thread. It would be better to always pass in the thread id. However, the thread an audio callback runs on can change when the underlying audio device change, and also it seems to be called from a thread pool in a round-robin fashion when audio remoting is activated, making the traces unreadable. The thread on which the AudioCallbackDriver::DataCallback is to always be thread 0, and the budget is set to always be thread 1. This allows displaying those elements in two separate lanes. The other thread have "normal" tid. Hashing allows being able to get a string representation that is unique and guaranteed to be portable. 4574
UnderrunHandler.h 970
UnderrunHandlerLinux.cpp 2322
UnderrunHandlerNoop.cpp 460
VideoFrameContainer.cpp 9041
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. 5761
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. 15303
VideoLimits.h 775
VideoOutput.h 10799
VideoPlaybackQuality.cpp 1537
VideoPlaybackQuality.h 1625
VideoSegment.cpp static 3680
VideoSegment.h 5654
VideoStreamTrack.cpp 2842
VideoStreamTrack.h Whether this VideoStreamTrack's video frames will have an alpha channel. 1742
VideoTrack.cpp 2890
VideoTrack.h 2198
VideoTrackList.cpp 2822
VideoTrackList.h 1413
VideoUtils.cpp 24635
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. 19808
VorbisUtils.h MOZ_SAMPLE_TYPE_FLOAT32 867
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. 3721
WebMSample.h 1731681
WebVTTListener.cpp 6494
WebVTTListener.h Loads the WebVTTListener. Must call this in order for the listener to be ready to parse data that is passed to it. 2227
XiphExtradata.cpp 2931
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. 1169
benchmark 1
bridge 4
components.conf 2994
doctor 30
eme 28
encoder 14
fake-cdm 8
flac 7
fuzz 2
gmp This directory contains code supporting Gecko Media Plugins (GMPs). The GMP API is not the same thing as the Media Plugin API (MPAPI). 93
gmp-plugin-openh264 3
gtest 72
hls 7
imagecapture 5
ipc 38
mediacapabilities 12
mediacontrol 26
mediasession 7
mediasink 10
mediasource 26 9942
mp3 7
mp4 25
nsIAudioDeviceInfo.idl 1959
nsIAutoplay.idl Possible values for the "media.autoplay.default" preference. 583
nsIDOMNavigatorUserMedia.idl 788
nsIDocumentActivity.h Use this macro when declaring classes that implement this interface. 1127
nsIMediaManager.idl return a array of inner windows that have active captures 1721
ogg 15
platforms 19
systemservices 41
test 988
tests 1
wave 5
webaudio 102
webm 12
webrtc 39
webspeech 3
webvtt 9