MockRealtimeAudioSource.cpp [plain text]
#include "config.h"
#include "MockRealtimeAudioSource.h"
#if ENABLE(MEDIA_STREAM)
#include "CaptureDevice.h"
#include "Logging.h"
#include "MediaConstraints.h"
#include "MockRealtimeMediaSourceCenter.h"
#include "NotImplemented.h"
#include "RealtimeMediaSourceSettings.h"
#include <wtf/UUID.h>
namespace WebCore {
class MockRealtimeAudioSourceFactory : public RealtimeMediaSource::AudioCaptureFactory
{
public:
CaptureSourceOrError createAudioCaptureSource(const CaptureDevice& device, const MediaConstraints* constraints) final
{
for (auto& mockDevice : MockRealtimeMediaSource::audioDevices()) {
if (mockDevice.persistentId() == device.persistentId())
return MockRealtimeAudioSource::create(mockDevice.persistentId(), mockDevice.label(), constraints);
}
return { };
}
};
#if !PLATFORM(MAC) && !PLATFORM(IOS) && !(USE(GSTREAMER) && USE(LIBWEBRTC))
CaptureSourceOrError MockRealtimeAudioSource::create(const String& deviceID, const String& name, const MediaConstraints* constraints)
{
auto source = adoptRef(*new MockRealtimeAudioSource(deviceID, name));
if (constraints && source->applyConstraints(*constraints))
return { };
return CaptureSourceOrError(WTFMove(source));
}
#endif
static MockRealtimeAudioSourceFactory& mockAudioCaptureSourceFactory()
{
static NeverDestroyed<MockRealtimeAudioSourceFactory> factory;
return factory.get();
}
RealtimeMediaSource::AudioCaptureFactory& MockRealtimeAudioSource::factory()
{
return mockAudioCaptureSourceFactory();
}
MockRealtimeAudioSource::MockRealtimeAudioSource(const String& deviceID, const String& name)
: MockRealtimeMediaSource(deviceID, RealtimeMediaSource::Type::Audio, name)
, m_timer(RunLoop::current(), this, &MockRealtimeAudioSource::tick)
{
}
MockRealtimeAudioSource::~MockRealtimeAudioSource()
{
#if PLATFORM(IOS)
MockRealtimeMediaSourceCenter::audioCaptureSourceFactory().unsetActiveSource(*this);
#endif
}
void MockRealtimeAudioSource::updateSettings(RealtimeMediaSourceSettings& settings)
{
settings.setVolume(volume());
settings.setEchoCancellation(echoCancellation());
settings.setSampleRate(sampleRate());
}
void MockRealtimeAudioSource::initializeCapabilities(RealtimeMediaSourceCapabilities& capabilities)
{
capabilities.setVolume(CapabilityValueOrRange(0.0, 1.0));
capabilities.setEchoCancellation(RealtimeMediaSourceCapabilities::EchoCancellation::ReadWrite);
capabilities.setSampleRate(CapabilityValueOrRange(44100, 48000));
}
void MockRealtimeAudioSource::initializeSupportedConstraints(RealtimeMediaSourceSupportedConstraints& supportedConstraints)
{
supportedConstraints.setSupportsVolume(true);
supportedConstraints.setSupportsEchoCancellation(true);
supportedConstraints.setSupportsSampleRate(true);
}
void MockRealtimeAudioSource::startProducingData()
{
#if PLATFORM(IOS)
MockRealtimeMediaSourceCenter::audioCaptureSourceFactory().setActiveSource(*this);
#endif
if (!sampleRate())
setSampleRate(WTF::get<MockMicrophoneProperties>(device().properties).defaultSampleRate);
m_startTime = MonotonicTime::now();
m_timer.startRepeating(renderInterval());
}
void MockRealtimeAudioSource::stopProducingData()
{
m_timer.stop();
m_elapsedTime += MonotonicTime::now() - m_startTime;
m_startTime = MonotonicTime::nan();
}
Seconds MockRealtimeAudioSource::elapsedTime()
{
if (std::isnan(m_startTime))
return m_elapsedTime;
return m_elapsedTime + (MonotonicTime::now() - m_startTime);
}
void MockRealtimeAudioSource::tick()
{
if (std::isnan(m_lastRenderTime))
m_lastRenderTime = MonotonicTime::now();
MonotonicTime now = MonotonicTime::now();
if (m_delayUntil) {
if (m_delayUntil < now)
return;
m_delayUntil = MonotonicTime();
}
Seconds delta = now - m_lastRenderTime;
m_lastRenderTime = now;
render(delta);
}
void MockRealtimeAudioSource::delaySamples(Seconds delta)
{
m_delayUntil = MonotonicTime::now() + delta;
}
}
#endif // ENABLE(MEDIA_STREAM)