Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-02-28 05:10:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1129263 - Part 6. Remove DOMMediaStream::TrackTypeHints. r=roc,jesup

Browse Source
This commit is contained in:
Andreas Pehrson 2015-02-09 15:23:34 +08:00
parent 68db4947b3
commit 9b19093204
15 changed files with 88 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
dom/camera/DOMCameraControl.cpp
View File

@ -264,7 +264,6 @@ nsDOMCameraControl::nsDOMCameraControl(uint32_t aCameraId,
mCurrentConfiguration = initialConfig.forget();
// Attach our DOM-facing media stream to our viewfinder stream.
SetHintContents(HINT_CONTENTS_VIDEO);
InitStreamCommon(mInput);
MOZ_ASSERT(mWindow, "Shouldn't be created with a null window!");
if (mWindow->GetExtantDoc()) {

66
dom/html/HTMLMediaElement.cpp
View File

@ -1858,31 +1858,7 @@ HTMLMediaElement::CaptureStreamInternal(bool aFinishWhenEnded)
}
#endif
OutputMediaStream* out = mOutputStreams.AppendElement();
uint8_t hints = 0;
if (mReadyState >= nsIDOMHTMLMediaElement::HAVE_METADATA) {
hints = (HasAudio()? DOMMediaStream::HINT_CONTENTS_AUDIO : 0) |
(HasVideo()? DOMMediaStream::HINT_CONTENTS_VIDEO : 0);
} else {
#ifdef DEBUG
// Estimate hints based on the type of the media element
// under the preference media.capturestream_hints for the
// debug builds only. This allows WebRTC Peer Connection
// to behave appropriately when media streams generated
// via mozCaptureStream*() are added to the Peer Connection.
// This functionality is planned to be used as part of Audio
// Quality Performance testing for WebRTC.
// Bug932845: Revisit this once hints mechanism is dealt with
// holistically.
if (Preferences::GetBool("media.capturestream_hints.enabled")) {
if (IsVideo() && GetVideoFrameContainer()) {
hints = DOMMediaStream::HINT_CONTENTS_VIDEO | DOMMediaStream::HINT_CONTENTS_AUDIO;
} else {
hints = DOMMediaStream::HINT_CONTENTS_AUDIO;
}
}
#endif
}
out->mStream = DOMMediaStream::CreateTrackUnionStream(window, hints);
out->mStream = DOMMediaStream::CreateTrackUnionStream(window);
nsRefPtr<nsIPrincipal> principal = GetCurrentPrincipal();
out->mStream->CombineWithPrincipal(principal);
out->mStream->SetCORSMode(mCORSMode);
@ -1896,6 +1872,17 @@ HTMLMediaElement::CaptureStreamInternal(bool aFinishWhenEnded)
if (mDecoder) {
mDecoder->AddOutputStream(
out->mStream->GetStream()->AsProcessedStream(), aFinishWhenEnded);
if (mReadyState >= HAVE_METADATA) {
// Expose the tracks to JS directly.
if (HasAudio()) {
TrackID audioTrackId = mMediaInfo.mAudio.mTrackInfo.mOutputId;
out->mStream->CreateDOMTrack(audioTrackId, MediaSegment::AUDIO);
}
if (HasVideo()) {
TrackID videoTrackId = mMediaInfo.mVideo.mTrackInfo.mOutputId;
out->mStream->CreateDOMTrack(videoTrackId, MediaSegment::VIDEO);
}
}
}
nsRefPtr<DOMMediaStream> result = out->mStream;
return result.forget();
@ -2928,9 +2915,8 @@ class HTMLMediaElement::MediaStreamTracksAvailableCallback:
public DOMMediaStream::OnTracksAvailableCallback
{
public:
explicit MediaStreamTracksAvailableCallback(HTMLMediaElement* aElement,
DOMMediaStream::TrackTypeHints aExpectedTracks = 0):
DOMMediaStream::OnTracksAvailableCallback(aExpectedTracks),
explicit MediaStreamTracksAvailableCallback(HTMLMediaElement* aElement):
DOMMediaStream::OnTracksAvailableCallback(),
mElement(aElement)
{}
virtual void NotifyTracksAvailable(DOMMediaStream* aStream)
@ -2987,9 +2973,6 @@ void HTMLMediaElement::SetupSrcMediaStreamPlayback(DOMMediaStream* aStream)
GetSrcMediaStream()->ChangeExplicitBlockerCount(1);
}
mSrcStream->OnTracksAvailable(new MediaStreamTracksAvailableCallback(this, DOMMediaStream::HINT_CONTENTS_AUDIO));
mSrcStream->OnTracksAvailable(new MediaStreamTracksAvailableCallback(this, DOMMediaStream::HINT_CONTENTS_VIDEO));
ChangeNetworkState(nsIDOMHTMLMediaElement::NETWORK_IDLE);
ChangeDelayLoadStatus(false);
@ -3006,6 +2989,8 @@ void HTMLMediaElement::SetupSrcMediaStreamPlayback(DOMMediaStream* aStream)
// mSrcStream
mSrcStream->ConstructMediaTracks(AudioTracks(), VideoTracks());
mSrcStream->OnTracksAvailable(new MediaStreamTracksAvailableCallback(this));
// FirstFrameLoaded() will be called when the stream has current data.
}
@ -3084,12 +3069,16 @@ void HTMLMediaElement::MetadataLoaded(const MediaInfo* aInfo,
mDecoder->SetFragmentEndTime(mFragmentEnd);
}
// Tracks just got known, pass the info along to the output streams
uint8_t hints = (HasAudio() ? DOMMediaStream::HINT_CONTENTS_AUDIO : 0) |
(HasVideo() ? DOMMediaStream::HINT_CONTENTS_VIDEO : 0);
for (uint32_t i = 0; i < mOutputStreams.Length(); ++i) {
OutputMediaStream* out = &mOutputStreams[i];
out->mStream->SetHintContents(hints);
// Expose the tracks to JS directly.
for (OutputMediaStream& out : mOutputStreams) {
if (aInfo->HasAudio()) {
TrackID audioTrackId = aInfo->mAudio.mTrackInfo.mOutputId;
out.mStream->CreateDOMTrack(audioTrackId, MediaSegment::AUDIO);
}
if (aInfo->HasVideo()) {
TrackID videoTrackId = aInfo->mVideo.mTrackInfo.mOutputId;
out.mStream->CreateDOMTrack(videoTrackId, MediaSegment::VIDEO);
}
}
// If this element had a video track, but consists only of an audio track now,
@ -4265,8 +4254,7 @@ void HTMLMediaElement::UpdateAudioChannelPlayingState()
(HasAttr(kNameSpaceID_None, nsGkAtoms::loop) ||
(mReadyState >= nsIDOMHTMLMediaElement::HAVE_CURRENT_DATA &&
!IsPlaybackEnded() &&
!(mSrcStream && !(mSrcStream->GetTrackTypesAvailable() &
DOMMediaStream::HINT_CONTENTS_AUDIO))) ||
(!mSrcStream || HasAudio())) ||
mPlayingThroughTheAudioChannelBeforeSeek));
if (playingThroughTheAudioChannel != mPlayingThroughTheAudioChannel) {
mPlayingThroughTheAudioChannel = playingThroughTheAudioChannel;

66
dom/media/DOMMediaStream.cpp
View File

@ -274,20 +274,18 @@ DOMMediaStream::IsFinished()
}
void
DOMMediaStream::InitSourceStream(nsIDOMWindow* aWindow, TrackTypeHints aHintContents)
DOMMediaStream::InitSourceStream(nsIDOMWindow* aWindow)
{
mWindow = aWindow;
SetHintContents(aHintContents);
MediaStreamGraph* gm = MediaStreamGraph::GetInstance(aHintContents);
MediaStreamGraph* gm = MediaStreamGraph::GetInstance();
InitStreamCommon(gm->CreateSourceStream(this));
}
void
DOMMediaStream::InitTrackUnionStream(nsIDOMWindow* aWindow, TrackTypeHints aHintContents)
DOMMediaStream::InitTrackUnionStream(nsIDOMWindow* aWindow)
{
mWindow = aWindow;
SetHintContents(aHintContents);
MediaStreamGraph* gm = MediaStreamGraph::GetInstance(aHintContents);
MediaStreamGraph* gm = MediaStreamGraph::GetInstance();
InitStreamCommon(gm->CreateTrackUnionStream(this));
}
@ -302,18 +300,18 @@ DOMMediaStream::InitStreamCommon(MediaStream* aStream)
}
already_AddRefed<DOMMediaStream>
DOMMediaStream::CreateSourceStream(nsIDOMWindow* aWindow, TrackTypeHints aHintContents)
DOMMediaStream::CreateSourceStream(nsIDOMWindow* aWindow)
{
nsRefPtr<DOMMediaStream> stream = new DOMMediaStream();
stream->InitSourceStream(aWindow, aHintContents);
stream->InitSourceStream(aWindow);
return stream.forget();
}
already_AddRefed<DOMMediaStream>
DOMMediaStream::CreateTrackUnionStream(nsIDOMWindow* aWindow, TrackTypeHints aHintContents)
DOMMediaStream::CreateTrackUnionStream(nsIDOMWindow* aWindow)
{
nsRefPtr<DOMMediaStream> stream = new DOMMediaStream();
stream->InitTrackUnionStream(aWindow, aHintContents);
stream->InitTrackUnionStream(aWindow);
return stream.forget();
}
@ -386,23 +384,15 @@ DOMMediaStream::RemovePrincipalChangeObserver(PrincipalChangeObserver* aObserver
return mPrincipalChangeObservers.RemoveElement(aObserver);
}
void
DOMMediaStream::SetHintContents(TrackTypeHints aHintContents)
{
mHintContents |= aHintContents;
}
MediaStreamTrack*
DOMMediaStream::CreateDOMTrack(TrackID aTrackID, MediaSegment::Type aType)
{
MediaStreamTrack* track;
switch (aType) {
case MediaSegment::AUDIO:
mHintContents |= HINT_CONTENTS_AUDIO;
track = new AudioStreamTrack(this, aTrackID);
break;
case MediaSegment::VIDEO:
mHintContents |= HINT_CONTENTS_VIDEO;
track = new VideoStreamTrack(this, aTrackID);
break;
default:
@ -424,7 +414,6 @@ DOMMediaStream::BindDOMTrack(TrackID aTrackID, MediaSegment::Type aType)
track = mTracks[i]->AsAudioStreamTrack();
if (track && track->GetTrackID() == aTrackID) {
bindSuccess = true;
mTrackTypesAvailable |= HINT_CONTENTS_AUDIO;
break;
}
}
@ -435,7 +424,6 @@ DOMMediaStream::BindDOMTrack(TrackID aTrackID, MediaSegment::Type aType)
track = mTracks[i]->AsVideoStreamTrack();
if (track && track->GetTrackID() == aTrackID) {
bindSuccess = true;
mTrackTypesAvailable |= HINT_CONTENTS_VIDEO;
break;
}
}
@ -444,9 +432,6 @@ DOMMediaStream::BindDOMTrack(TrackID aTrackID, MediaSegment::Type aType)
default:
MOZ_CRASH("Unhandled track type");
}
if (bindSuccess) {
CheckTracksAvailable();
}
return bindSuccess ? track : nullptr;
}
@ -513,13 +498,7 @@ DOMMediaStream::CheckTracksAvailable()
callbacks.SwapElements(mRunOnTracksAvailable);
for (uint32_t i = 0; i < callbacks.Length(); ++i) {
OnTracksAvailableCallback* cb = callbacks[i];
if (~mTrackTypesAvailable & cb->GetExpectedTracks()) {
// Some expected tracks not available yet. Try this callback again later.
*mRunOnTracksAvailable.AppendElement() = callbacks[i].forget();
continue;
}
cb->NotifyTracksAvailable(this);
callbacks[i]->NotifyTracksAvailable(this);
}
}
@ -552,14 +531,10 @@ void
DOMMediaStream::ConstructMediaTracks(AudioTrackList* aAudioTrackList,
VideoTrackList* aVideoTrackList)
{
if (mHintContents & DOMMediaStream::HINT_CONTENTS_AUDIO) {
MediaTrackListListener listener(aAudioTrackList);
mMediaTrackListListeners.AppendElement(listener);
}
if (mHintContents & DOMMediaStream::HINT_CONTENTS_VIDEO) {
MediaTrackListListener listener(aVideoTrackList);
mMediaTrackListListeners.AppendElement(listener);
}
MediaTrackListListener audioListener(aAudioTrackList);
mMediaTrackListListeners.AppendElement(audioListener);
MediaTrackListListener videoListener(aVideoTrackList);
mMediaTrackListListeners.AppendElement(videoListener);
int firstEnabledVideo = -1;
for (uint32_t i = 0; i < mTracks.Length(); ++i) {
@ -648,20 +623,18 @@ DOMLocalMediaStream::Stop()
}
already_AddRefed<DOMLocalMediaStream>
DOMLocalMediaStream::CreateSourceStream(nsIDOMWindow* aWindow,
TrackTypeHints aHintContents)
DOMLocalMediaStream::CreateSourceStream(nsIDOMWindow* aWindow)
{
nsRefPtr<DOMLocalMediaStream> stream = new DOMLocalMediaStream();
stream->InitSourceStream(aWindow, aHintContents);
stream->InitSourceStream(aWindow);
return stream.forget();
}
already_AddRefed<DOMLocalMediaStream>
DOMLocalMediaStream::CreateTrackUnionStream(nsIDOMWindow* aWindow,
TrackTypeHints aHintContents)
DOMLocalMediaStream::CreateTrackUnionStream(nsIDOMWindow* aWindow)
{
nsRefPtr<DOMLocalMediaStream> stream = new DOMLocalMediaStream();
stream->InitTrackUnionStream(aWindow, aHintContents);
stream->InitTrackUnionStream(aWindow);
return stream.forget();
}
@ -676,10 +649,9 @@ DOMAudioNodeMediaStream::~DOMAudioNodeMediaStream()
already_AddRefed<DOMAudioNodeMediaStream>
DOMAudioNodeMediaStream::CreateTrackUnionStream(nsIDOMWindow* aWindow,
AudioNode* aNode,
TrackTypeHints aHintContents)
AudioNode* aNode)
{
nsRefPtr<DOMAudioNodeMediaStream> stream = new DOMAudioNodeMediaStream(aNode);
stream->InitTrackUnionStream(aWindow, aHintContents);
stream->InitTrackUnionStream(aWindow);
return stream.forget();
}

36
dom/media/DOMMediaStream.h
View File

@ -177,28 +177,17 @@ public:
// need to surface this to content.
void AssignId(const nsAString& aID) { mID = aID; }
// Indicate what track types we eventually expect to add to this stream
enum {
HINT_CONTENTS_AUDIO = 1 << 0,
HINT_CONTENTS_VIDEO = 1 << 1,
HINT_CONTENTS_UNKNOWN = 1 << 2
};
TrackTypeHints GetHintContents() const { return mHintContents; }
void SetHintContents(TrackTypeHints aHintContents);
TrackTypeHints GetTrackTypesAvailable() const { return mTrackTypesAvailable; }
/**
* Create an nsDOMMediaStream whose underlying stream is a SourceMediaStream.
*/
static already_AddRefed<DOMMediaStream>
CreateSourceStream(nsIDOMWindow* aWindow, TrackTypeHints aHintContents);
CreateSourceStream(nsIDOMWindow* aWindow);
/**
* Create an nsDOMMediaStream whose underlying stream is a TrackUnionStream.
*/
static already_AddRefed<DOMMediaStream>
CreateTrackUnionStream(nsIDOMWindow* aWindow, TrackTypeHints aHintContents = 0);
CreateTrackUnionStream(nsIDOMWindow* aWindow);
void SetLogicalStreamStartTime(StreamTime aTime)
{
@ -213,14 +202,8 @@ public:
class OnTracksAvailableCallback {
public:
explicit OnTracksAvailableCallback(uint8_t aExpectedTracks = 0)
: mExpectedTracks(aExpectedTracks) {}
virtual ~OnTracksAvailableCallback() {}
virtual void NotifyTracksAvailable(DOMMediaStream* aStream) = 0;
TrackTypeHints GetExpectedTracks() { return mExpectedTracks; }
void SetExpectedTracks(TrackTypeHints aExpectedTracks) { mExpectedTracks = aExpectedTracks; }
private:
TrackTypeHints mExpectedTracks;
};
// When one track of the appropriate type has been added for each bit set
// in aCallback->GetExpectedTracks(), run aCallback->NotifyTracksAvailable.
@ -266,8 +249,8 @@ protected:
virtual ~DOMMediaStream();
void Destroy();
void InitSourceStream(nsIDOMWindow* aWindow, TrackTypeHints aHintContents);
void InitTrackUnionStream(nsIDOMWindow* aWindow, TrackTypeHints aHintContents);
void InitSourceStream(nsIDOMWindow* aWindow);
void InitTrackUnionStream(nsIDOMWindow* aWindow);
void InitStreamCommon(MediaStream* aStream);
already_AddRefed<AudioTrack> CreateAudioTrack(AudioStreamTrack* aStreamTrack);
already_AddRefed<VideoTrack> CreateVideoTrack(VideoStreamTrack* aStreamTrack);
@ -304,10 +287,6 @@ protected:
// Keep these alive until the stream finishes
nsTArray<nsCOMPtr<nsISupports> > mConsumersToKeepAlive;
// Indicate what track types we eventually expect to add to this stream
uint8_t mHintContents;
// Indicate what track types have arrived in this stream
uint8_t mTrackTypesAvailable;
bool mNotifiedOfMediaStreamGraphShutdown;
// Send notifications to AudioTrackList or VideoTrackList, if this MediaStream
@ -352,13 +331,13 @@ public:
* Create an nsDOMLocalMediaStream whose underlying stream is a SourceMediaStream.
*/
static already_AddRefed<DOMLocalMediaStream>
CreateSourceStream(nsIDOMWindow* aWindow, TrackTypeHints aHintContents);
CreateSourceStream(nsIDOMWindow* aWindow);
/**
* Create an nsDOMLocalMediaStream whose underlying stream is a TrackUnionStream.
*/
static already_AddRefed<DOMLocalMediaStream>
CreateTrackUnionStream(nsIDOMWindow* aWindow, TrackTypeHints aHintContents = 0);
CreateTrackUnionStream(nsIDOMWindow* aWindow);
protected:
virtual ~DOMLocalMediaStream();
@ -381,8 +360,7 @@ public:
*/
static already_AddRefed<DOMAudioNodeMediaStream>
CreateTrackUnionStream(nsIDOMWindow* aWindow,
AudioNode* aNode,
TrackTypeHints aHintContents = 0);
AudioNode* aNode);
protected:
~DOMAudioNodeMediaStream();

6
dom/media/MediaManager.cpp
View File

@ -567,14 +567,10 @@ public:
MediaEngineSource* aAudioSource,
MediaEngineSource* aVideoSource)
{
DOMMediaStream::TrackTypeHints hints =
(aAudioSource ? DOMMediaStream::HINT_CONTENTS_AUDIO : 0) |
(aVideoSource ? DOMMediaStream::HINT_CONTENTS_VIDEO : 0);
nsRefPtr<nsDOMUserMediaStream> stream = new nsDOMUserMediaStream(aListener,
aAudioSource,
aVideoSource);
stream->InitTrackUnionStream(aWindow, hints);
stream->InitTrackUnionStream(aWindow);
return stream.forget();
}

11
dom/media/MediaManager.h
View File

@ -393,21 +393,16 @@ public:
NS_ASSERTION(!NS_IsMainThread(), "Never call on main thread");
nsresult rv;
DOMMediaStream::TrackTypeHints expectedTracks = 0;
if (mAudioSource) {
rv = mAudioSource->Start(source, kAudioTrack);
if (NS_SUCCEEDED(rv)) {
expectedTracks |= DOMMediaStream::HINT_CONTENTS_AUDIO;
} else {
if (NS_FAILED(rv)) {
ReturnCallbackError(rv, "Starting audio failed");
return;
}
}
if (mVideoSource) {
rv = mVideoSource->Start(source, kVideoTrack);
if (NS_SUCCEEDED(rv)) {
expectedTracks |= DOMMediaStream::HINT_CONTENTS_VIDEO;
} else {
if (NS_FAILED(rv)) {
ReturnCallbackError(rv, "Starting video failed");
return;
}
@ -415,8 +410,6 @@ public:
// Start() queued the tracks to be added synchronously to avoid races
source->FinishAddTracks();
mOnTracksAvailableCallback->SetExpectedTracks(expectedTracks);
source->SetPullEnabled(true);
source->AdvanceKnownTracksTime(STREAM_TIME_MAX);

32
dom/media/MediaRecorder.cpp
View File

@ -295,23 +295,21 @@ class MediaRecorder::Session: public nsIObserver
: mSession(aSession) {}
virtual void NotifyTracksAvailable(DOMMediaStream* aStream)
{
uint8_t trackType = aStream->GetHintContents();
// ToDo: GetHintContents return 0 when recording media tags.
if (trackType == 0) {
nsTArray<nsRefPtr<mozilla::dom::AudioStreamTrack> > audioTracks;
aStream->GetAudioTracks(audioTracks);
nsTArray<nsRefPtr<mozilla::dom::VideoStreamTrack> > videoTracks;
aStream->GetVideoTracks(videoTracks);
// What is inside the track
if (videoTracks.Length() > 0) {
trackType |= DOMMediaStream::HINT_CONTENTS_VIDEO;
}
if (audioTracks.Length() > 0) {
trackType |= DOMMediaStream::HINT_CONTENTS_AUDIO;
}
uint8_t trackTypes = 0;
nsTArray<nsRefPtr<mozilla::dom::AudioStreamTrack>> audioTracks;
aStream->GetAudioTracks(audioTracks);
if (!audioTracks.IsEmpty()) {
trackTypes |= ContainerWriter::CREATE_AUDIO_TRACK;
}
LOG(PR_LOG_DEBUG, ("Session.NotifyTracksAvailable track type = (%d)", trackType));
mSession->InitEncoder(trackType);
nsTArray<nsRefPtr<mozilla::dom::VideoStreamTrack>> videoTracks;
aStream->GetVideoTracks(videoTracks);
if (!videoTracks.IsEmpty()) {
trackTypes |= ContainerWriter::CREATE_VIDEO_TRACK;
}
LOG(PR_LOG_DEBUG, ("Session.NotifyTracksAvailable track type = (%d)", trackTypes));
mSession->InitEncoder(trackTypes);
}
private:
nsRefPtr<Session> mSession;
@ -542,7 +540,7 @@ private:
domStream->OnTracksAvailable(tracksAvailableCallback);
} else {
// Web Audio node has only audio.
InitEncoder(DOMMediaStream::HINT_CONTENTS_AUDIO);
InitEncoder(ContainerWriter::CREATE_AUDIO_TRACK);
}
}

11
dom/media/MediaStreamGraph.cpp
View File

@ -2737,7 +2737,7 @@ ProcessedMediaStream::DestroyImpl()
MediaStreamGraphImpl::MediaStreamGraphImpl(bool aRealtime,
TrackRate aSampleRate,
DOMMediaStream::TrackTypeHints aHint= DOMMediaStream::HINT_CONTENTS_UNKNOWN,
bool aStartWithAudioDriver,
dom::AudioChannel aChannel)
: MediaStreamGraph(aSampleRate)
, mProcessingGraphUpdateIndex(0)
@ -2776,7 +2776,7 @@ MediaStreamGraphImpl::MediaStreamGraphImpl(bool aRealtime,
#endif
if (mRealtime) {
if (aHint & DOMMediaStream::HINT_CONTENTS_AUDIO) {
if (aStartWithAudioDriver) {
AudioCallbackDriver* driver = new AudioCallbackDriver(this, aChannel);
mDriver = driver;
mMixer.AddCallback(driver);
@ -2784,7 +2784,7 @@ MediaStreamGraphImpl::MediaStreamGraphImpl(bool aRealtime,
mDriver = new SystemClockDriver(this);
}
} else {
mDriver = new OfflineClockDriver(this, MEDIA_GRAPH_TARGET_PERIOD_MS);
mDriver = new OfflineClockDriver(this, MEDIA_GRAPH_TARGET_PERIOD_MS);
}
mLastMainThreadUpdate = TimeStamp::Now();
@ -2833,7 +2833,8 @@ MediaStreamGraphShutdownObserver::Observe(nsISupports *aSubject,
}
MediaStreamGraph*
MediaStreamGraph::GetInstance(DOMMediaStream::TrackTypeHints aHint, dom::AudioChannel aChannel)
MediaStreamGraph::GetInstance(bool aStartWithAudioDriver,
dom::AudioChannel aChannel)
{
NS_ASSERTION(NS_IsMainThread(), "Main thread only");
@ -2848,7 +2849,7 @@ MediaStreamGraph::GetInstance(DOMMediaStream::TrackTypeHints aHint, dom::AudioCh
CubebUtils::InitPreferredSampleRate();
graph = new MediaStreamGraphImpl(true, CubebUtils::PreferredSampleRate(), aHint, aChannel);
graph = new MediaStreamGraphImpl(true, CubebUtils::PreferredSampleRate(), aStartWithAudioDriver, aChannel);
gGraphs.Put(channel, graph);
STREAM_LOG(PR_LOG_DEBUG, ("Starting up MediaStreamGraph %p", graph));

2
dom/media/MediaStreamGraph.h
View File

@ -1181,7 +1181,7 @@ public:
//
// Main thread only
static MediaStreamGraph* GetInstance(DOMMediaStream::TrackTypeHints aHint = DOMMediaStream::HINT_CONTENTS_UNKNOWN,
static MediaStreamGraph* GetInstance(bool aStartWithAudioDriver = false,
dom::AudioChannel aChannel = dom::AudioChannel::Normal);
static MediaStreamGraph* CreateNonRealtimeInstance(TrackRate aSampleRate);
// Idempotent

2
dom/media/MediaStreamGraphImpl.h
View File

@ -99,7 +99,7 @@ public:
*/
explicit MediaStreamGraphImpl(bool aRealtime,
TrackRate aSampleRate,
DOMMediaStream::TrackTypeHints aHint,
bool aStartWithAudioDriver = false,
dom::AudioChannel aChannel = dom::AudioChannel::Normal);
/**

3
dom/media/webaudio/AudioDestinationNode.cpp
View File

@ -354,9 +354,10 @@ AudioDestinationNode::AudioDestinationNode(AudioContext* aContext,
, mExtraCurrentTimeSinceLastStartedBlocking(0)
, mExtraCurrentTimeUpdatedSinceLastStableState(false)
{
bool startWithAudioDriver = true;
MediaStreamGraph* graph = aIsOffline ?
MediaStreamGraph::CreateNonRealtimeInstance(aSampleRate) :
MediaStreamGraph::GetInstance(DOMMediaStream::HINT_CONTENTS_AUDIO, aChannel);
MediaStreamGraph::GetInstance(startWithAudioDriver, aChannel);
AudioNodeEngine* engine = aIsOffline ?
new OfflineDestinationNodeEngine(this, aNumberOfChannels,
aLength, aSampleRate) :

3
dom/media/webaudio/MediaStreamAudioDestinationNode.cpp
View File

@ -68,8 +68,7 @@ MediaStreamAudioDestinationNode::MediaStreamAudioDestinationNode(AudioContext* a
ChannelCountMode::Explicit,
ChannelInterpretation::Speakers)
, mDOMStream(DOMAudioNodeMediaStream::CreateTrackUnionStream(GetOwner(),
this,
DOMMediaStream::HINT_CONTENTS_AUDIO))
this))
{
TrackUnionStream* tus = static_cast<TrackUnionStream*>(mDOMStream->GetStream());
MOZ_ASSERT(tus == mDOMStream->GetStream()->AsProcessedStream());

15
media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp
View File

@ -182,10 +182,7 @@ public:
size_t numNewVideoTracks,
const std::string& pcHandle,
nsRefPtr<PeerConnectionObserver> aObserver)
: DOMMediaStream::OnTracksAvailableCallback(
// Once DOMMediaStream can handle more than one of each, this will change.
(numNewAudioTracks ? DOMMediaStream::HINT_CONTENTS_AUDIO : 0) |
(numNewVideoTracks ? DOMMediaStream::HINT_CONTENTS_VIDEO : 0))
: DOMMediaStream::OnTracksAvailableCallback()
, mObserver(aObserver)
, mPcHandle(pcHandle)
{}
@ -450,10 +447,10 @@ PeerConnectionImpl::~PeerConnectionImpl()
}
already_AddRefed<DOMMediaStream>
PeerConnectionImpl::MakeMediaStream(uint32_t aHint)
PeerConnectionImpl::MakeMediaStream()
{
nsRefPtr<DOMMediaStream> stream =
DOMMediaStream::CreateSourceStream(GetWindow(), aHint);
DOMMediaStream::CreateSourceStream(GetWindow());
#ifdef MOZILLA_INTERNAL_API
// Make the stream data (audio/video samples) accessible to the receiving page.
@ -486,11 +483,7 @@ PeerConnectionImpl::CreateRemoteSourceStreamInfo(nsRefPtr<RemoteSourceStreamInfo
MOZ_ASSERT(aInfo);
PC_AUTO_ENTER_API_CALL_NO_CHECK();
// We need to pass a dummy hint here because FakeMediaStream currently
// needs to actually propagate a hint for local streams.
// TODO(ekr@rtfm.com): Clean up when we have explicit track lists.
// See bug 834835.
nsRefPtr<DOMMediaStream> stream = MakeMediaStream(0);
nsRefPtr<DOMMediaStream> stream = MakeMediaStream();
if (!stream) {
return NS_ERROR_FAILURE;
}

2
media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h
View File

@ -264,7 +264,7 @@ public:
IceConfiguration *aDst);
static nsresult AddIceServer(const RTCIceServer& aServer,
IceConfiguration* aDst);
already_AddRefed<DOMMediaStream> MakeMediaStream(uint32_t aHint);
already_AddRefed<DOMMediaStream> MakeMediaStream();
nsresult CreateRemoteSourceStreamInfo(nsRefPtr<RemoteSourceStreamInfo>* aInfo,
const std::string& aId);

2
media/webrtc/signaling/test/FakeMediaStreams.h
View File

@ -280,7 +280,7 @@ public:
NS_DECL_THREADSAFE_ISUPPORTS
static already_AddRefed<Fake_DOMMediaStream>
CreateSourceStream(nsIDOMWindow* aWindow, uint32_t aHintContents) {
CreateSourceStream(nsIDOMWindow* aWindow, uint32_t aHintContents = 0) {
Fake_SourceMediaStream *source = new Fake_SourceMediaStream();
nsRefPtr<Fake_DOMMediaStream> ds = new Fake_DOMMediaStream(source);