summaryrefslogtreecommitdiffstats
path: root/media/webrtc/signaling/test/FakeMediaStreamsImpl.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /media/webrtc/signaling/test/FakeMediaStreamsImpl.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'media/webrtc/signaling/test/FakeMediaStreamsImpl.h')
-rw-r--r--media/webrtc/signaling/test/FakeMediaStreamsImpl.h236
1 files changed, 236 insertions, 0 deletions
diff --git a/media/webrtc/signaling/test/FakeMediaStreamsImpl.h b/media/webrtc/signaling/test/FakeMediaStreamsImpl.h
new file mode 100644
index 000000000..da0e81416
--- /dev/null
+++ b/media/webrtc/signaling/test/FakeMediaStreamsImpl.h
@@ -0,0 +1,236 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef FAKE_MEDIA_STREAMIMPL_H_
+#define FAKE_MEDIA_STREAMIMPL_H_
+
+#include "FakeMediaStreams.h"
+
+#include "nspr.h"
+#include "nsError.h"
+
+void LogTime(AsyncLatencyLogger::LatencyLogIndex index, uint64_t b, int64_t c) {}
+void LogLatency(AsyncLatencyLogger::LatencyLogIndex index, uint64_t b, int64_t c) {}
+
+static const int AUDIO_BUFFER_SIZE = 1600;
+static const int NUM_CHANNELS = 2;
+static const int GRAPH_RATE = 16000;
+
+NS_IMPL_ISUPPORTS0(Fake_DOMMediaStream)
+
+// Fake_MediaStream
+double Fake_MediaStream::StreamTimeToSeconds(mozilla::StreamTime aTime) {
+ return static_cast<double>(aTime)/GRAPH_RATE;
+}
+
+mozilla::TrackTicks Fake_MediaStream::TimeToTicksRoundUp(mozilla::TrackRate aRate,
+ mozilla::StreamTime aTime) {
+ return (aTime * aRate) / GRAPH_RATE;
+}
+
+mozilla::StreamTime
+Fake_MediaStream::TicksToTimeRoundDown(mozilla::TrackRate aRate,
+ mozilla::TrackTicks aTicks) {
+ return aTicks * GRAPH_RATE / aRate;
+}
+
+// Fake_SourceMediaStream
+nsresult Fake_SourceMediaStream::Start() {
+ mTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
+ if (!mTimer) {
+ return NS_ERROR_FAILURE;
+ }
+
+ mTimer->InitWithCallback(mPeriodic, 100, nsITimer::TYPE_REPEATING_SLACK);
+
+ return NS_OK;
+}
+
+nsresult Fake_SourceMediaStream::Stop() {
+ mozilla::MutexAutoLock lock(mMutex);
+ if (mTimer)
+ mTimer->Cancel();
+ mPeriodic->Detach();
+ return NS_OK;
+}
+
+void Fake_SourceMediaStream::Periodic() {
+ mozilla::MutexAutoLock lock(mMutex);
+ // Pull more audio-samples iff pulling is enabled
+ // and we are not asked by the signaling agent to stop
+ //pulling data.
+ if (mPullEnabled && !mStop) {
+ // 100 ms matches timer interval and AUDIO_BUFFER_SIZE @ 16000 Hz
+ mDesiredTime += 100;
+ for (std::set<RefPtr<Fake_MediaStreamListener>>::iterator it =
+ mListeners.begin(); it != mListeners.end(); ++it) {
+ (*it)->NotifyPull(nullptr, TicksToTimeRoundDown(1000 /* ms per s */,
+ mDesiredTime));
+ }
+ }
+}
+
+// Fake_MediaStreamTrack
+void Fake_MediaStreamTrack::AddListener(Fake_MediaStreamTrackListener *aListener)
+{
+ mOwningStream->GetInputStream()->AddTrackListener(aListener, mTrackID);
+}
+void Fake_MediaStreamTrack::RemoveListener(Fake_MediaStreamTrackListener *aListener)
+{
+ mOwningStream->GetInputStream()->RemoveTrackListener(aListener, mTrackID);
+}
+
+// Fake_MediaStreamBase
+nsresult Fake_MediaStreamBase::Start() {
+ mTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
+ if (!mTimer) {
+ return NS_ERROR_FAILURE;
+ }
+
+ mTimer->InitWithCallback(mPeriodic, 100, nsITimer::TYPE_REPEATING_SLACK);
+
+ return NS_OK;
+}
+
+nsresult Fake_MediaStreamBase::Stop() {
+ // Lock the mutex so that we know that after this
+ // has returned, periodic will not be firing again
+ // and so it's safe to destruct.
+ mozilla::MutexAutoLock lock(mMutex);
+ mTimer->Cancel();
+
+ return NS_OK;
+}
+
+// Fake_AudioStreamSource
+void Fake_AudioStreamSource::Periodic() {
+ mozilla::MutexAutoLock lock(mMutex);
+ //Are we asked to stop pumping audio samples ?
+ if(mStop) {
+ return;
+ }
+ //Generate Signed 16 Bit Audio samples
+ RefPtr<mozilla::SharedBuffer> samples =
+ mozilla::SharedBuffer::Create(AUDIO_BUFFER_SIZE * NUM_CHANNELS * sizeof(int16_t));
+ int16_t* data = reinterpret_cast<int16_t *>(samples->Data());
+ for(int i=0; i<(1600*2); i++) {
+ //saw tooth audio sample
+ data[i] = ((mCount % 8) * 4000) - (7*4000)/2;
+ mCount++;
+ }
+
+ mozilla::AudioSegment segment;
+ AutoTArray<const int16_t *,1> channels;
+ channels.AppendElement(data);
+ segment.AppendFrames(samples.forget(),
+ channels,
+ AUDIO_BUFFER_SIZE,
+ PRINCIPAL_HANDLE_NONE);
+
+ for(std::set<RefPtr<Fake_MediaStreamListener>>::iterator it = mListeners.begin();
+ it != mListeners.end(); ++it) {
+ (*it)->NotifyQueuedTrackChanges(nullptr, // Graph
+ 0, // TrackID
+ 0, // Offset TODO(ekr@rtfm.com) fix
+ static_cast<mozilla::TrackEventCommand>(0), // ???
+ segment,
+ nullptr, // Input stream
+ -1); // Input track id
+ }
+ for(std::vector<BoundTrackListener>::iterator it = mTrackListeners.begin();
+ it != mTrackListeners.end(); ++it) {
+ it->mListener->NotifyQueuedChanges(nullptr, // Graph
+ 0, // Offset TODO(ekr@rtfm.com) fix
+ segment);
+ }
+}
+
+
+// Fake_MediaPeriodic
+NS_IMPL_ISUPPORTS(Fake_MediaPeriodic, nsITimerCallback)
+
+NS_IMETHODIMP
+Fake_MediaPeriodic::Notify(nsITimer *timer) {
+ if (mStream)
+ mStream->Periodic();
+ ++mCount;
+ return NS_OK;
+}
+
+
+#if 0
+#define WIDTH 320
+#define HEIGHT 240
+#define RATE USECS_PER_S
+#define USECS_PER_S 1000000
+#define FPS 10
+
+NS_IMETHODIMP
+Fake_VideoStreamSource::Notify(nsITimer* aTimer)
+{
+#if 0
+ mozilla::layers::BufferRecycleBin bin;
+
+ RefPtr<mozilla::layers::PlanarYCbCrImage> image = new
+ mozilla::layers::PlanarYCbCrImage(&bin);
+
+ const uint8_t lumaBpp = 8;
+ const uint8_t chromaBpp = 4;
+
+ int len = ((WIDTH * HEIGHT) * 3 / 2);
+ uint8_t* frame = (uint8_t*) PR_Malloc(len);
+ memset(frame, 0x80, len); // Gray
+
+ mozilla::layers::PlanarYCbCrData data;
+ data.mYChannel = frame;
+ data.mYSize = mozilla::gfx::IntSize(WIDTH, HEIGHT);
+ data.mYStride = WIDTH * lumaBpp / 8.0;
+ data.mCbCrStride = WIDTH * chromaBpp / 8.0;
+ data.mCbChannel = frame + HEIGHT * data.mYStride;
+ data.mCrChannel = data.mCbChannel + HEIGHT * data.mCbCrStride / 2;
+ data.mCbCrSize = mozilla::gfx::IntSize(WIDTH / 2, HEIGHT / 2);
+ data.mPicX = 0;
+ data.mPicY = 0;
+ data.mPicSize = mozilla::gfx::IntSize(WIDTH, HEIGHT);
+ data.mStereoMode = mozilla::layers::StereoMode::MONO;
+
+ mozilla::VideoSegment segment;
+ segment.AppendFrame(image.forget(), USECS_PER_S / FPS,
+ mozilla::gfx::IntSize(WIDTH, HEIGHT));
+
+ // TODO(ekr@rtfm.com): are we leaking?
+#endif
+
+ return NS_OK;
+}
+
+
+#if 0
+// Fake up buffer recycle bin
+mozilla::layers::BufferRecycleBin::BufferRecycleBin() :
+ mLock("mozilla.layers.BufferRecycleBin.mLock") {
+}
+
+void mozilla::layers::BufferRecycleBin::RecycleBuffer(uint8_t* buffer, uint32_t size) {
+ PR_Free(buffer);
+}
+
+uint8_t *mozilla::layers::BufferRecycleBin::GetBuffer(uint32_t size) {
+ return (uint8_t *)PR_MALLOC(size);
+}
+
+// YCbCrImage constructor (from ImageLayers.cpp)
+mozilla::layers::PlanarYCbCrImage::PlanarYCbCrImage(BufferRecycleBin *aRecycleBin)
+ : Image(nsnull, ImageFormat::PLANAR_YCBCR)
+ , mBufferSize(0)
+ , mRecycleBin(aRecycleBin)
+{
+}
+
+
+#endif
+#endif
+
+
+#endif