diff options
Diffstat (limited to '')
| -rw-r--r-- | dom/media/gtest/TestAudioInputProcessing.cpp | 127 | ||||
| -rw-r--r-- | dom/media/gtest/TestAudioPacketizer.cpp | 51 | ||||
| -rw-r--r-- | dom/media/gtest/TestAudioTrackGraph.cpp | 311 | ||||
| -rw-r--r-- | dom/media/gtest/TestDeviceInputTrack.cpp | 8 | ||||
| -rw-r--r-- | dom/media/gtest/TestMediaDataEncoder.cpp | 125 |
5 files changed, 377 insertions, 245 deletions
diff --git a/dom/media/gtest/TestAudioInputProcessing.cpp b/dom/media/gtest/TestAudioInputProcessing.cpp index 82c1831e84..d21c37a900 100644 --- a/dom/media/gtest/TestAudioInputProcessing.cpp +++ b/dom/media/gtest/TestAudioInputProcessing.cpp @@ -30,11 +30,21 @@ class MockGraph : public MediaTrackGraphImpl { void Init(uint32_t aChannels) { MediaTrackGraphImpl::Init(OFFLINE_THREAD_DRIVER, DIRECT_DRIVER, aChannels); - // Remove this graph's driver since it holds a ref. If no AppendMessage - // takes place, the driver never starts. This will also make sure no-one - // tries to use it. We are still kept alive by the self-ref. Destroy() must - // be called to break that cycle. - SetCurrentDriver(nullptr); + + MonitorAutoLock lock(mMonitor); + // We don't need a graph driver. Advance to + // LIFECYCLE_WAITING_FOR_TRACK_DESTRUCTION so that the driver never + // starts. Graph control messages run as in shutdown, synchronously. + // This permits the main thread part of track initialization through + // AudioProcessingTrack::Create(). + mLifecycleState = LIFECYCLE_WAITING_FOR_TRACK_DESTRUCTION; +#ifdef DEBUG + mCanRunMessagesSynchronously = true; +#endif + // Remove this graph's driver since it holds a ref. We are still kept + // alive by the self-ref. Destroy() must be called to break that cycle if + // no tracks are created and destroyed. + mDriver = nullptr; } MOCK_CONST_METHOD0(OnGraphThread, bool()); @@ -53,6 +63,7 @@ TEST(TestAudioInputProcessing, Buffering) const uint32_t channels = 1; auto graph = MakeRefPtr<NiceMock<MockGraph>>(rate); graph->Init(channels); + RefPtr track = AudioProcessingTrack::Create(graph); auto aip = MakeRefPtr<AudioInputProcessing>(channels); @@ -62,19 +73,26 @@ TEST(TestAudioInputProcessing, Buffering) GraphTime processedTime; GraphTime nextTime; AudioSegment output; + MediaEnginePrefs settings; + settings.mChannels = channels; + // pref "media.getusermedia.agc2_forced" defaults to true. + // mAgc would need to be set to something other than kAdaptiveAnalog + // for mobile, as asserted in AudioInputProcessing::ConfigForPrefs, + // if gain_controller1 were used. + settings.mAgc2Forced = true; // Toggle pass-through mode without starting { - EXPECT_EQ(aip->PassThrough(graph), false); - EXPECT_EQ(aip->NumBufferedFrames(graph), 0); - - aip->SetPassThrough(graph, true); + EXPECT_EQ(aip->IsPassThrough(graph), true); EXPECT_EQ(aip->NumBufferedFrames(graph), 0); - aip->SetPassThrough(graph, false); + settings.mAgcOn = true; + aip->ApplySettings(graph, nullptr, settings); + EXPECT_EQ(aip->IsPassThrough(graph), false); EXPECT_EQ(aip->NumBufferedFrames(graph), 0); - aip->SetPassThrough(graph, true); + settings.mAgcOn = false; + aip->ApplySettings(graph, nullptr, settings); EXPECT_EQ(aip->NumBufferedFrames(graph), 0); } @@ -88,14 +106,15 @@ TEST(TestAudioInputProcessing, Buffering) AudioSegment input; generator.Generate(input, nextTime - processedTime); - aip->Process(graph, processedTime, nextTime, &input, &output); + aip->Process(track, processedTime, nextTime, &input, &output); EXPECT_EQ(input.GetDuration(), nextTime - processedTime); EXPECT_EQ(output.GetDuration(), nextTime); EXPECT_EQ(aip->NumBufferedFrames(graph), 0); } // Set aip to processing/non-pass-through mode - aip->SetPassThrough(graph, false); + settings.mAgcOn = true; + aip->ApplySettings(graph, nullptr, settings); { // Need (nextTime - processedTime) = 256 - 128 = 128 frames this round. // aip has not started yet, so output will be filled with silence data @@ -106,37 +125,35 @@ TEST(TestAudioInputProcessing, Buffering) AudioSegment input; generator.Generate(input, nextTime - processedTime); - aip->Process(graph, processedTime, nextTime, &input, &output); + aip->Process(track, processedTime, nextTime, &input, &output); EXPECT_EQ(input.GetDuration(), nextTime - processedTime); EXPECT_EQ(output.GetDuration(), nextTime); EXPECT_EQ(aip->NumBufferedFrames(graph), 0); } - // aip has been started and set to processing mode so it will insert 80 frames - // into aip's internal buffer as pre-buffering. + // aip has been set to processing mode and is started. aip->Start(graph); { // Need (nextTime - processedTime) = 256 - 256 = 0 frames this round. - // The Process() aip will take 0 frames from input, packetize and process - // these frames into 0 80-frame packet(0 frames left in packetizer), insert - // packets into aip's internal buffer, then move 0 frames the internal - // buffer to output, leaving 80 + 0 - 0 = 80 frames in aip's internal - // buffer. + // Process() will return early on 0 frames of input. + // Pre-buffering is not triggered. processedTime = nextTime; nextTime = MediaTrackGraphImpl::RoundUpToEndOfAudioBlock(3 * frames); AudioSegment input; generator.Generate(input, nextTime - processedTime); - aip->Process(graph, processedTime, nextTime, &input, &output); + aip->Process(track, processedTime, nextTime, &input, &output); EXPECT_EQ(input.GetDuration(), nextTime - processedTime); EXPECT_EQ(output.GetDuration(), nextTime); - EXPECT_EQ(aip->NumBufferedFrames(graph), 80); + EXPECT_EQ(aip->NumBufferedFrames(graph), 0); } { // Need (nextTime - processedTime) = 384 - 256 = 128 frames this round. - // The Process() aip will take 128 frames from input, packetize and process + // On receipt of the these first frames, aip will insert 80 frames + // into its internal buffer as pre-buffering. + // Process() will take 128 frames from input, packetize and process // these frames into floor(128/80) = 1 80-frame packet (48 frames left in // packetizer), insert packets into aip's internal buffer, then move 128 // frames the internal buffer to output, leaving 80 + 80 - 128 = 32 frames @@ -147,7 +164,7 @@ TEST(TestAudioInputProcessing, Buffering) AudioSegment input; generator.Generate(input, nextTime - processedTime); - aip->Process(graph, processedTime, nextTime, &input, &output); + aip->Process(track, processedTime, nextTime, &input, &output); EXPECT_EQ(input.GetDuration(), nextTime - processedTime); EXPECT_EQ(output.GetDuration(), nextTime); EXPECT_EQ(aip->NumBufferedFrames(graph), 32); @@ -161,7 +178,7 @@ TEST(TestAudioInputProcessing, Buffering) AudioSegment input; generator.Generate(input, nextTime - processedTime); - aip->Process(graph, processedTime, nextTime, &input, &output); + aip->Process(track, processedTime, nextTime, &input, &output); EXPECT_EQ(input.GetDuration(), nextTime - processedTime); EXPECT_EQ(output.GetDuration(), nextTime); EXPECT_EQ(aip->NumBufferedFrames(graph), 32); @@ -180,13 +197,15 @@ TEST(TestAudioInputProcessing, Buffering) AudioSegment input; generator.Generate(input, nextTime - processedTime); - aip->Process(graph, processedTime, nextTime, &input, &output); + aip->Process(track, processedTime, nextTime, &input, &output); EXPECT_EQ(input.GetDuration(), nextTime - processedTime); EXPECT_EQ(output.GetDuration(), nextTime); EXPECT_EQ(aip->NumBufferedFrames(graph), 64); } - aip->SetPassThrough(graph, true); + // Set aip to pass-through mode + settings.mAgcOn = false; + aip->ApplySettings(graph, nullptr, settings); { // Need (nextTime - processedTime) = 512 - 512 = 0 frames this round. // No buffering in pass-through mode @@ -196,14 +215,14 @@ TEST(TestAudioInputProcessing, Buffering) AudioSegment input; generator.Generate(input, nextTime - processedTime); - aip->Process(graph, processedTime, nextTime, &input, &output); + aip->Process(track, processedTime, nextTime, &input, &output); EXPECT_EQ(input.GetDuration(), nextTime - processedTime); EXPECT_EQ(output.GetDuration(), processedTime); EXPECT_EQ(aip->NumBufferedFrames(graph), 0); } aip->Stop(graph); - graph->Destroy(); + track->Destroy(); } TEST(TestAudioInputProcessing, ProcessDataWithDifferentPrincipals) @@ -212,6 +231,7 @@ TEST(TestAudioInputProcessing, ProcessDataWithDifferentPrincipals) const uint32_t channels = 2; auto graph = MakeRefPtr<NiceMock<MockGraph>>(rate); graph->Init(channels); + RefPtr track = AudioProcessingTrack::Create(graph); auto aip = MakeRefPtr<AudioInputProcessing>(channels); AudioGenerator<AudioDataValue> generator(channels, rate); @@ -271,26 +291,30 @@ TEST(TestAudioInputProcessing, ProcessDataWithDifferentPrincipals) }; // Check the principals in audio-processing mode. - EXPECT_EQ(aip->PassThrough(graph), false); + MediaEnginePrefs settings; + settings.mChannels = channels; + settings.mAgcOn = true; + settings.mAgc2Forced = true; + aip->ApplySettings(graph, nullptr, settings); + EXPECT_EQ(aip->IsPassThrough(graph), false); aip->Start(graph); { - EXPECT_EQ(aip->NumBufferedFrames(graph), 480); AudioSegment output; { - // Trim the prebuffering silence. - AudioSegment data; - aip->Process(graph, 0, 4800, &input, &data); + aip->Process(track, 0, 4800, &input, &data); EXPECT_EQ(input.GetDuration(), 4800); EXPECT_EQ(data.GetDuration(), 4800); + // Extract another 480 frames to account for delay from pre-buffering. + EXPECT_EQ(aip->NumBufferedFrames(graph), 480); AudioSegment dummy; dummy.AppendNullData(480); - aip->Process(graph, 0, 480, &dummy, &data); + aip->Process(track, 0, 480, &dummy, &data); EXPECT_EQ(dummy.GetDuration(), 480); EXPECT_EQ(data.GetDuration(), 480 + 4800); - // Ignore the pre-buffering data + // Ignore the pre-buffering silence. output.AppendSlice(data, 480, 480 + 4800); } @@ -298,10 +322,12 @@ TEST(TestAudioInputProcessing, ProcessDataWithDifferentPrincipals) } // Check the principals in pass-through mode. - aip->SetPassThrough(graph, true); + settings.mAgcOn = false; + aip->ApplySettings(graph, nullptr, settings); + EXPECT_EQ(aip->IsPassThrough(graph), true); { AudioSegment output; - aip->Process(graph, 0, 4800, &input, &output); + aip->Process(track, 0, 4800, &input, &output); EXPECT_EQ(input.GetDuration(), 4800); EXPECT_EQ(output.GetDuration(), 4800); @@ -309,7 +335,7 @@ TEST(TestAudioInputProcessing, ProcessDataWithDifferentPrincipals) } aip->Stop(graph); - graph->Destroy(); + track->Destroy(); } TEST(TestAudioInputProcessing, Downmixing) @@ -318,6 +344,7 @@ TEST(TestAudioInputProcessing, Downmixing) const uint32_t channels = 4; auto graph = MakeRefPtr<NiceMock<MockGraph>>(rate); graph->Init(channels); + RefPtr track = AudioProcessingTrack::Create(graph); auto aip = MakeRefPtr<AudioInputProcessing>(channels); @@ -327,7 +354,12 @@ TEST(TestAudioInputProcessing, Downmixing) GraphTime processedTime; GraphTime nextTime; - aip->SetPassThrough(graph, false); + MediaEnginePrefs settings; + settings.mChannels = channels; + settings.mAgcOn = true; + settings.mAgc2Forced = true; + aip->ApplySettings(graph, nullptr, settings); + EXPECT_EQ(aip->IsPassThrough(graph), false); aip->Start(graph); processedTime = 0; @@ -347,7 +379,7 @@ TEST(TestAudioInputProcessing, Downmixing) // downmix to mono, scaling the input by 1/4 in the process. // We can't compare the input and output signal because the sine is going to // be mangledui - aip->Process(graph, processedTime, nextTime, &input, &output); + aip->Process(track, processedTime, nextTime, &input, &output); EXPECT_EQ(input.GetDuration(), nextTime - processedTime); EXPECT_EQ(output.GetDuration(), nextTime); EXPECT_EQ(output.MaxChannelCount(), 1u); @@ -367,15 +399,18 @@ TEST(TestAudioInputProcessing, Downmixing) } } - // Now, repeat the test, checking we get the unmodified 4 channels. - aip->SetPassThrough(graph, true); + // Now, repeat the test in pass-through mode, checking we get the unmodified + // 4 channels. + settings.mAgcOn = false; + aip->ApplySettings(graph, nullptr, settings); + EXPECT_EQ(aip->IsPassThrough(graph), true); AudioSegment input, output; processedTime = nextTime; nextTime += MediaTrackGraphImpl::RoundUpToEndOfAudioBlock(frames); generator.Generate(input, nextTime - processedTime); - aip->Process(graph, processedTime, nextTime, &input, &output); + aip->Process(track, processedTime, nextTime, &input, &output); EXPECT_EQ(input.GetDuration(), nextTime - processedTime); EXPECT_EQ(output.GetDuration(), nextTime - processedTime); // This time, no downmix: 4 channels of input, 4 channels of output @@ -391,5 +426,5 @@ TEST(TestAudioInputProcessing, Downmixing) } aip->Stop(graph); - graph->Destroy(); + track->Destroy(); } diff --git a/dom/media/gtest/TestAudioPacketizer.cpp b/dom/media/gtest/TestAudioPacketizer.cpp index 96a2d6f08c..2c9f86bb14 100644 --- a/dom/media/gtest/TestAudioPacketizer.cpp +++ b/dom/media/gtest/TestAudioPacketizer.cpp @@ -7,6 +7,7 @@ #include <math.h> #include <memory> #include "../AudioPacketizer.h" +#include "../TimedPacketizer.h" #include "gtest/gtest.h" using namespace mozilla; @@ -25,16 +26,15 @@ class AutoBuffer { int16_t Sequence(int16_t* aBuffer, uint32_t aSize, uint32_t aStart = 0) { uint32_t i; for (i = 0; i < aSize; i++) { - aBuffer[i] = aStart + i; + aBuffer[i] = (aStart + i) % INT16_MAX; } return aStart + i; } -void IsSequence(std::unique_ptr<int16_t[]> aBuffer, uint32_t aSize, - uint32_t aStart = 0) { +void IsSequence(int16_t* aBuffer, uint32_t aSize, uint32_t aStart = 0) { for (uint32_t i = 0; i < aSize; i++) { - ASSERT_TRUE(aBuffer[i] == static_cast<int64_t>(aStart + i)) - << "Buffer is not a sequence at offset " << i << '\n'; + ASSERT_EQ(aBuffer[i], static_cast<int64_t>((aStart + i) % INT16_MAX)) + << "Buffer is not a sequence at offset " << i << '\n'; } // Buffer is a sequence. } @@ -70,7 +70,7 @@ TEST(AudioPacketizer, Test) seqEnd = Sequence(b.Get(), channels * 441, prevEnd); ap.Input(b.Get(), 441); std::unique_ptr<int16_t[]> out(ap.Output()); - IsSequence(std::move(out), 441 * channels, prevEnd); + IsSequence(out.get(), 441 * channels, prevEnd); } } // Simple test, with input/output buffer size aligned on the packet size, @@ -89,8 +89,8 @@ TEST(AudioPacketizer, Test) ap.Input(b1.Get(), 441); std::unique_ptr<int16_t[]> out(ap.Output()); std::unique_ptr<int16_t[]> out2(ap.Output()); - IsSequence(std::move(out), 441 * channels, prevEnd0); - IsSequence(std::move(out2), 441 * channels, prevEnd1); + IsSequence(out.get(), 441 * channels, prevEnd0); + IsSequence(out2.get(), 441 * channels, prevEnd1); } } // Input/output buffer size not aligned on the packet size, @@ -108,9 +108,9 @@ TEST(AudioPacketizer, Test) ap.Input(b1.Get(), 480); std::unique_ptr<int16_t[]> out(ap.Output()); std::unique_ptr<int16_t[]> out2(ap.Output()); - IsSequence(std::move(out), 441 * channels, prevEnd); + IsSequence(out.get(), 441 * channels, prevEnd); prevEnd += 441 * channels; - IsSequence(std::move(out2), 441 * channels, prevEnd); + IsSequence(out2.get(), 441 * channels, prevEnd); prevEnd += 441 * channels; } printf("Available: %d\n", ap.PacketsAvailable()); @@ -161,3 +161,34 @@ TEST(AudioPacketizer, Test) } } } + +TEST(TimedPacketizer, Test) +{ + const int channels = 2; + const int64_t rate = 48000; + const int64_t inputPacketSize = 240; + const int64_t packetSize = 96; + TimedPacketizer<int16_t, int16_t> tp(packetSize, channels, 0, rate); + int16_t prevEnd = 0; + int16_t prevSeq = 0; + nsTArray<int16_t> packet; + uint64_t tsCheck = 0; + packet.SetLength(tp.PacketSize() * channels); + for (int16_t i = 0; i < 10; i++) { + AutoBuffer<int16_t> b(inputPacketSize * channels); + prevSeq = Sequence(b.Get(), inputPacketSize * channels, prevSeq); + tp.Input(b.Get(), inputPacketSize); + while (tp.PacketsAvailable()) { + media::TimeUnit ts = tp.Output(packet.Elements()); + IsSequence(packet.Elements(), packetSize * channels, prevEnd); + EXPECT_EQ(ts, media::TimeUnit(tsCheck, rate)); + prevEnd += packetSize * channels; + tsCheck += packetSize; + } + } + EXPECT_TRUE(!tp.PacketsAvailable()); + uint32_t drained; + media::TimeUnit ts = tp.Drain(packet.Elements(), drained); + EXPECT_EQ(ts, media::TimeUnit(tsCheck, rate)); + EXPECT_LE(drained, packetSize); +} diff --git a/dom/media/gtest/TestAudioTrackGraph.cpp b/dom/media/gtest/TestAudioTrackGraph.cpp index 1bd255bed1..7be1224ab9 100644 --- a/dom/media/gtest/TestAudioTrackGraph.cpp +++ b/dom/media/gtest/TestAudioTrackGraph.cpp @@ -59,39 +59,27 @@ struct StopInputProcessing : public ControlMessage { void Run() override { mInputProcessing->Stop(mTrack->Graph()); } }; -struct SetPassThrough : public ControlMessage { - const RefPtr<AudioInputProcessing> mInputProcessing; - const bool mPassThrough; - - SetPassThrough(MediaTrack* aTrack, AudioInputProcessing* aInputProcessing, - bool aPassThrough) - : ControlMessage(aTrack), - mInputProcessing(aInputProcessing), - mPassThrough(aPassThrough) {} - void Run() override { - EXPECT_EQ(mInputProcessing->PassThrough(mTrack->Graph()), !mPassThrough); - mInputProcessing->SetPassThrough(mTrack->Graph(), mPassThrough); - } -}; - -struct SetRequestedInputChannelCount : public ControlMessage { - const CubebUtils::AudioDeviceID mDeviceId; - const RefPtr<AudioInputProcessing> mInputProcessing; - const uint32_t mChannelCount; +void QueueApplySettings(AudioProcessingTrack* aTrack, + AudioInputProcessing* aInputProcessing, + const MediaEnginePrefs& aSettings) { + aTrack->QueueControlMessageWithNoShutdown( + [inputProcessing = RefPtr{aInputProcessing}, aSettings, + // If the track is not connected to a device then the particular + // AudioDeviceID (nullptr) passed to ReevaluateInputDevice() is not + // important. + deviceId = aTrack->DeviceId().valueOr(nullptr), + graph = aTrack->Graph()] { + inputProcessing->ApplySettings(graph, deviceId, aSettings); + }); +} - SetRequestedInputChannelCount(MediaTrack* aTrack, - CubebUtils::AudioDeviceID aDeviceId, - AudioInputProcessing* aInputProcessing, - uint32_t aChannelCount) - : ControlMessage(aTrack), - mDeviceId(aDeviceId), - mInputProcessing(aInputProcessing), - mChannelCount(aChannelCount) {} - void Run() override { - mInputProcessing->SetRequestedInputChannelCount(mTrack->Graph(), mDeviceId, - mChannelCount); - } -}; +void QueueExpectIsPassThrough(AudioProcessingTrack* aTrack, + AudioInputProcessing* aInputProcessing) { + aTrack->QueueControlMessageWithNoShutdown( + [inputProcessing = RefPtr{aInputProcessing}, graph = aTrack->Graph()] { + EXPECT_EQ(inputProcessing->IsPassThrough(graph), true); + }); +} #endif // MOZ_WEBRTC class GoFaster : public ControlMessage { @@ -557,8 +545,7 @@ class TestDeviceInputConsumerTrack : public DeviceInputConsumerTrack { } else { MOZ_ASSERT(mInputs.Length() == 1); AudioSegment data; - DeviceInputConsumerTrack::GetInputSourceData(data, mInputs[0], aFrom, - aTo); + DeviceInputConsumerTrack::GetInputSourceData(data, aFrom, aTo); GetData<AudioSegment>()->AppendFrom(&data); } }; @@ -620,8 +607,8 @@ TEST(TestAudioTrackGraph, DeviceChangedCallback) TestDeviceInputConsumerTrack::Create(graphImpl); track1->ConnectDeviceInput(device1, listener1.get(), PRINCIPAL_HANDLE_NONE); - EXPECT_TRUE(track1->ConnectToNativeDevice()); - EXPECT_FALSE(track1->ConnectToNonNativeDevice()); + EXPECT_TRUE(track1->ConnectedToNativeDevice()); + EXPECT_FALSE(track1->ConnectedToNonNativeDevice()); auto started = Invoke([&] { return graphImpl->NotifyWhenDeviceStarted(nullptr); }); RefPtr<SmartMockCubebStream> stream1 = WaitFor(cubeb->StreamInitEvent()); @@ -637,8 +624,8 @@ TEST(TestAudioTrackGraph, DeviceChangedCallback) TestDeviceInputConsumerTrack::Create(graphImpl); track2->ConnectDeviceInput(device2, listener2.get(), PRINCIPAL_HANDLE_NONE); - EXPECT_FALSE(track2->ConnectToNativeDevice()); - EXPECT_TRUE(track2->ConnectToNonNativeDevice()); + EXPECT_FALSE(track2->ConnectedToNativeDevice()); + EXPECT_TRUE(track2->ConnectedToNonNativeDevice()); RefPtr<SmartMockCubebStream> stream2 = WaitFor(cubeb->StreamInitEvent()); EXPECT_TRUE(stream2->mHasInput); EXPECT_FALSE(stream2->mHasOutput); @@ -852,8 +839,8 @@ TEST(TestAudioTrackGraph, RestartAudioIfMaxChannelCountChanged) track1->ConnectDeviceInput(nativeDevice, listener1.get(), PRINCIPAL_HANDLE_NONE); - EXPECT_TRUE(track1->ConnectToNativeDevice()); - EXPECT_FALSE(track1->ConnectToNonNativeDevice()); + EXPECT_TRUE(track1->ConnectedToNativeDevice()); + EXPECT_FALSE(track1->ConnectedToNonNativeDevice()); auto started = Invoke([&] { return graphImpl->NotifyWhenDeviceStarted(nullptr); }); nativeStream = WaitFor(cubeb->StreamInitEvent()); @@ -891,8 +878,8 @@ TEST(TestAudioTrackGraph, RestartAudioIfMaxChannelCountChanged) TestDeviceInputConsumerTrack::Create(graphImpl); track3->ConnectDeviceInput(nonNativeDevice, listener3.get(), PRINCIPAL_HANDLE_NONE); - EXPECT_FALSE(track3->ConnectToNativeDevice()); - EXPECT_TRUE(track3->ConnectToNonNativeDevice()); + EXPECT_FALSE(track3->ConnectedToNativeDevice()); + EXPECT_TRUE(track3->ConnectedToNonNativeDevice()); RefPtr<SmartMockCubebStream> nonNativeStream = WaitFor(cubeb->StreamInitEvent()); @@ -1176,8 +1163,7 @@ TEST(TestAudioTrackGraph, ErrorCallback) auto started = Invoke([&] { processingTrack = AudioProcessingTrack::Create(graph); listener = new AudioInputProcessing(2); - processingTrack->GraphImpl()->AppendMessage( - MakeUnique<SetPassThrough>(processingTrack, listener, true)); + QueueExpectIsPassThrough(processingTrack, listener); processingTrack->SetInputProcessing(listener); processingTrack->GraphImpl()->AppendMessage( MakeUnique<StartInputProcessing>(processingTrack, listener)); @@ -1247,8 +1233,7 @@ TEST(TestAudioTrackGraph, AudioProcessingTrack) port = outputTrack->AllocateInputPort(processingTrack); /* Primary graph: Open Audio Input through SourceMediaTrack */ listener = new AudioInputProcessing(2); - processingTrack->GraphImpl()->AppendMessage( - MakeUnique<SetPassThrough>(processingTrack, listener, true)); + QueueExpectIsPassThrough(processingTrack, listener); processingTrack->SetInputProcessing(listener); processingTrack->GraphImpl()->AppendMessage( MakeUnique<StartInputProcessing>(processingTrack, listener)); @@ -1336,12 +1321,22 @@ TEST(TestAudioTrackGraph, ReConnectDeviceInput) outputTrack->QueueSetAutoend(false); outputTrack->AddAudioOutput(reinterpret_cast<void*>(1), nullptr); port = outputTrack->AllocateInputPort(processingTrack); - listener = new AudioInputProcessing(2); + + const int32_t channelCount = 2; + listener = new AudioInputProcessing(channelCount); processingTrack->SetInputProcessing(listener); processingTrack->GraphImpl()->AppendMessage( MakeUnique<StartInputProcessing>(processingTrack, listener)); processingTrack->ConnectDeviceInput(deviceId, listener, PRINCIPAL_HANDLE_NONE); + MediaEnginePrefs settings; + settings.mChannels = channelCount; + settings.mAgcOn = true; // Turn off pass-through. + // AGC1 Mode 0 interferes with AudioVerifier's frequency estimation + // through zero-crossing counts. + settings.mAgc2Forced = true; + QueueApplySettings(processingTrack, listener, settings); + return graph->NotifyWhenDeviceStarted(nullptr); }); @@ -1494,8 +1489,7 @@ TEST(TestAudioTrackGraph, AudioProcessingTrackDisabling) port = outputTrack->AllocateInputPort(processingTrack); /* Primary graph: Open Audio Input through SourceMediaTrack */ listener = new AudioInputProcessing(2); - processingTrack->GraphImpl()->AppendMessage( - MakeUnique<SetPassThrough>(processingTrack, listener, true)); + QueueExpectIsPassThrough(processingTrack, listener); processingTrack->SetInputProcessing(listener); processingTrack->ConnectDeviceInput(deviceId, listener, PRINCIPAL_HANDLE_NONE); @@ -1511,32 +1505,40 @@ TEST(TestAudioTrackGraph, AudioProcessingTrackDisabling) stream->SetOutputRecordingEnabled(true); // Wait for a second worth of audio data. - uint32_t totalFrames = 0; - WaitUntil(stream->FramesProcessedEvent(), [&](uint32_t aFrames) { - totalFrames += aFrames; - return totalFrames > static_cast<uint32_t>(graph->GraphRate()); - }); + uint64_t targetPosition = graph->GraphRate(); + auto AdvanceToTargetPosition = [&] { + DispatchFunction([&] { + processingTrack->GraphImpl()->AppendMessage(MakeUnique<GoFaster>(cubeb)); + }); + WaitUntil(stream->FramesProcessedEvent(), [&](uint32_t aFrames) { + // Position() gives a more up-to-date indication than summing aFrames if + // multiple events are queued. + if (stream->Position() < targetPosition) { + return false; + } + cubeb->DontGoFaster(); + return true; + }); + }; + AdvanceToTargetPosition(); const uint32_t ITERATION_COUNT = 5; uint32_t iterations = ITERATION_COUNT; - DisabledTrackMode currentMode = DisabledTrackMode::SILENCE_BLACK; + DisabledTrackMode nextMode = DisabledTrackMode::SILENCE_BLACK; while (iterations--) { // toggle the track enabled mode, wait a second, do this ITERATION_COUNT // times DispatchFunction([&] { - processingTrack->SetDisabledTrackMode(currentMode); - if (currentMode == DisabledTrackMode::SILENCE_BLACK) { - currentMode = DisabledTrackMode::ENABLED; + processingTrack->SetDisabledTrackMode(nextMode); + if (nextMode == DisabledTrackMode::SILENCE_BLACK) { + nextMode = DisabledTrackMode::ENABLED; } else { - currentMode = DisabledTrackMode::SILENCE_BLACK; + nextMode = DisabledTrackMode::SILENCE_BLACK; } }); - totalFrames = 0; - WaitUntil(stream->FramesProcessedEvent(), [&](uint32_t aFrames) { - totalFrames += aFrames; - return totalFrames > static_cast<uint32_t>(graph->GraphRate()); - }); + targetPosition += graph->GraphRate(); + AdvanceToTargetPosition(); } // Clean up. @@ -1595,8 +1597,7 @@ TEST(TestAudioTrackGraph, SetRequestedInputChannelCount) RefPtr<AudioProcessingTrack> track1 = AudioProcessingTrack::Create(graph); RefPtr<AudioInputProcessing> listener1 = new AudioInputProcessing(2); track1->SetInputProcessing(listener1); - track1->GraphImpl()->AppendMessage( - MakeUnique<SetPassThrough>(track1, listener1, true)); + QueueExpectIsPassThrough(track1, listener1); track1->GraphImpl()->AppendMessage( MakeUnique<StartInputProcessing>(track1, listener1)); track1->ConnectDeviceInput(device1, listener1, PRINCIPAL_HANDLE_NONE); @@ -1617,8 +1618,7 @@ TEST(TestAudioTrackGraph, SetRequestedInputChannelCount) RefPtr<AudioProcessingTrack> track2 = AudioProcessingTrack::Create(graph); RefPtr<AudioInputProcessing> listener2 = new AudioInputProcessing(1); track2->SetInputProcessing(listener2); - track2->GraphImpl()->AppendMessage( - MakeUnique<SetPassThrough>(track2, listener2, true)); + QueueExpectIsPassThrough(track2, listener2); track2->GraphImpl()->AppendMessage( MakeUnique<StartInputProcessing>(track2, listener2)); track2->ConnectDeviceInput(device2, listener2, PRINCIPAL_HANDLE_NONE); @@ -1635,7 +1635,7 @@ TEST(TestAudioTrackGraph, SetRequestedInputChannelCount) auto setNewChannelCount = [&](const RefPtr<AudioProcessingTrack> aTrack, const RefPtr<AudioInputProcessing>& aListener, RefPtr<SmartMockCubebStream>& aStream, - uint32_t aChannelCount) { + int32_t aChannelCount) { bool destroyed = false; MediaEventListener destroyListener = cubeb->StreamDestroyEvent().Connect( AbstractThread::GetCurrent(), @@ -1650,11 +1650,9 @@ TEST(TestAudioTrackGraph, SetRequestedInputChannelCount) newStream = aCreated; }); - DispatchFunction([&] { - aTrack->GraphImpl()->AppendMessage( - MakeUnique<SetRequestedInputChannelCount>(aTrack, *aTrack->DeviceId(), - aListener, aChannelCount)); - }); + MediaEnginePrefs settings; + settings.mChannels = aChannelCount; + QueueApplySettings(aTrack, aListener, settings); SpinEventLoopUntil<ProcessFailureBehavior::IgnoreAndContinue>( "TEST(TestAudioTrackGraph, SetRequestedInputChannelCount)"_ns, @@ -1726,14 +1724,12 @@ TEST(TestAudioTrackGraph, RestartAudioIfProcessingMaxChannelCountChanged) auto setNewChannelCount = [&](const RefPtr<AudioProcessingTrack>& aTrack, const RefPtr<AudioInputProcessing>& aListener, RefPtr<SmartMockCubebStream>& aStream, - uint32_t aChannelCount) { + int32_t aChannelCount) { ASSERT_TRUE(!!aTrack); ASSERT_TRUE(!!aListener); ASSERT_TRUE(!!aStream); ASSERT_TRUE(aStream->mHasInput); - ASSERT_NE(aChannelCount, 0U); - - const CubebUtils::AudioDeviceID device = *aTrack->DeviceId(); + ASSERT_NE(aChannelCount, 0); bool destroyed = false; MediaEventListener destroyListener = cubeb->StreamDestroyEvent().Connect( @@ -1749,11 +1745,9 @@ TEST(TestAudioTrackGraph, RestartAudioIfProcessingMaxChannelCountChanged) newStream = aCreated; }); - DispatchFunction([&] { - aTrack->GraphImpl()->AppendMessage( - MakeUnique<SetRequestedInputChannelCount>(aTrack, device, aListener, - aChannelCount)); - }); + MediaEnginePrefs settings; + settings.mChannels = aChannelCount; + QueueApplySettings(aTrack, aListener, settings); SpinEventLoopUntil<ProcessFailureBehavior::IgnoreAndContinue>( "TEST(TestAudioTrackGraph, RestartAudioIfProcessingMaxChannelCountChanged) #1"_ns, @@ -1794,8 +1788,7 @@ TEST(TestAudioTrackGraph, RestartAudioIfProcessingMaxChannelCountChanged) aTrack = AudioProcessingTrack::Create(graph); aListener = new AudioInputProcessing(aChannelCount); aTrack->SetInputProcessing(aListener); - aTrack->GraphImpl()->AppendMessage( - MakeUnique<SetPassThrough>(aTrack, aListener, true)); + QueueExpectIsPassThrough(aTrack, aListener); aTrack->GraphImpl()->AppendMessage( MakeUnique<StartInputProcessing>(aTrack, aListener)); @@ -1829,8 +1822,7 @@ TEST(TestAudioTrackGraph, RestartAudioIfProcessingMaxChannelCountChanged) track1 = AudioProcessingTrack::Create(graph); listener1 = new AudioInputProcessing(1); track1->SetInputProcessing(listener1); - track1->GraphImpl()->AppendMessage( - MakeUnique<SetPassThrough>(track1, listener1, true)); + QueueExpectIsPassThrough(track1, listener1); track1->GraphImpl()->AppendMessage( MakeUnique<StartInputProcessing>(track1, listener1)); track1->ConnectDeviceInput(nativeDevice, listener1, PRINCIPAL_HANDLE_NONE); @@ -1873,8 +1865,7 @@ TEST(TestAudioTrackGraph, RestartAudioIfProcessingMaxChannelCountChanged) RefPtr<AudioProcessingTrack> track3 = AudioProcessingTrack::Create(graph); RefPtr<AudioInputProcessing> listener3 = new AudioInputProcessing(1); track3->SetInputProcessing(listener3); - track3->GraphImpl()->AppendMessage( - MakeUnique<SetPassThrough>(track3, listener3, true)); + QueueExpectIsPassThrough(track3, listener3); track3->GraphImpl()->AppendMessage( MakeUnique<StartInputProcessing>(track3, listener3)); track3->ConnectDeviceInput(nonNativeDevice, listener3, @@ -1992,12 +1983,13 @@ TEST(TestAudioTrackGraph, SetInputChannelCountBeforeAudioCallbackDriver) DispatchFunction([&] { track = AudioProcessingTrack::Create(graph); listener = new AudioInputProcessing(2); - track->GraphImpl()->AppendMessage( - MakeUnique<SetPassThrough>(track, listener, true)); + QueueExpectIsPassThrough(track, listener); track->SetInputProcessing(listener); - track->GraphImpl()->AppendMessage( - MakeUnique<SetRequestedInputChannelCount>(track, deviceId, listener, - 1)); + + MediaEnginePrefs settings; + settings.mChannels = 1; + QueueApplySettings(track, listener, settings); + track->GraphImpl()->AppendMessage( MakeUnique<GuardMessage>(track, std::move(h))); }); @@ -2058,8 +2050,7 @@ TEST(TestAudioTrackGraph, StartAudioDeviceBeforeStartingAudioProcessing) DispatchFunction([&] { track = AudioProcessingTrack::Create(graph); listener = new AudioInputProcessing(2); - track->GraphImpl()->AppendMessage( - MakeUnique<SetPassThrough>(track, listener, true)); + QueueExpectIsPassThrough(track, listener); track->SetInputProcessing(listener); // Start audio device without starting audio processing. track->ConnectDeviceInput(deviceId, listener, PRINCIPAL_HANDLE_NONE); @@ -2124,8 +2115,7 @@ TEST(TestAudioTrackGraph, StopAudioProcessingBeforeStoppingAudioDevice) DispatchFunction([&] { track = AudioProcessingTrack::Create(graph); listener = new AudioInputProcessing(2); - track->GraphImpl()->AppendMessage( - MakeUnique<SetPassThrough>(track, listener, true)); + QueueExpectIsPassThrough(track, listener); track->SetInputProcessing(listener); track->GraphImpl()->AppendMessage( MakeUnique<StartInputProcessing>(track, listener)); @@ -2260,8 +2250,7 @@ TEST(TestAudioTrackGraph, SwitchNativeAudioProcessingTrack) RefPtr<AudioProcessingTrack> track1 = AudioProcessingTrack::Create(graph); RefPtr<AudioInputProcessing> listener1 = new AudioInputProcessing(1); track1->SetInputProcessing(listener1); - track1->GraphImpl()->AppendMessage( - MakeUnique<SetPassThrough>(track1, listener1, true)); + QueueExpectIsPassThrough(track1, listener1); track1->GraphImpl()->AppendMessage( MakeUnique<StartInputProcessing>(track1, listener1)); track1->ConnectDeviceInput(device1, listener1, PRINCIPAL_HANDLE_NONE); @@ -2284,8 +2273,7 @@ TEST(TestAudioTrackGraph, SwitchNativeAudioProcessingTrack) RefPtr<AudioProcessingTrack> track2 = AudioProcessingTrack::Create(graph); RefPtr<AudioInputProcessing> listener2 = new AudioInputProcessing(2); track2->SetInputProcessing(listener2); - track2->GraphImpl()->AppendMessage( - MakeUnique<SetPassThrough>(track2, listener2, true)); + QueueExpectIsPassThrough(track2, listener2); track2->GraphImpl()->AppendMessage( MakeUnique<StartInputProcessing>(track2, listener2)); track2->ConnectDeviceInput(device2, listener2, PRINCIPAL_HANDLE_NONE); @@ -2304,8 +2292,7 @@ TEST(TestAudioTrackGraph, SwitchNativeAudioProcessingTrack) RefPtr<AudioProcessingTrack> track3 = AudioProcessingTrack::Create(graph); RefPtr<AudioInputProcessing> listener3 = new AudioInputProcessing(1); track3->SetInputProcessing(listener3); - track3->GraphImpl()->AppendMessage( - MakeUnique<SetPassThrough>(track3, listener3, true)); + QueueExpectIsPassThrough(track3, listener3); track3->GraphImpl()->AppendMessage( MakeUnique<StartInputProcessing>(track3, listener3)); track3->ConnectDeviceInput(device3, listener3, PRINCIPAL_HANDLE_NONE); @@ -2410,8 +2397,7 @@ void TestCrossGraphPort(uint32_t aInputRate, uint32_t aOutputRate, /* Primary graph: Create input track and open it */ processingTrack = AudioProcessingTrack::Create(primary); listener = new AudioInputProcessing(2); - processingTrack->GraphImpl()->AppendMessage( - MakeUnique<SetPassThrough>(processingTrack, listener, true)); + QueueExpectIsPassThrough(processingTrack, listener); processingTrack->SetInputProcessing(listener); processingTrack->GraphImpl()->AppendMessage( MakeUnique<StartInputProcessing>(processingTrack, listener)); @@ -2632,8 +2618,7 @@ TEST(TestAudioTrackGraph, SecondaryOutputDevice) /* Create an input track and connect it to a device */ processingTrack = AudioProcessingTrack::Create(graph); listener = new AudioInputProcessing(2); - processingTrack->GraphImpl()->AppendMessage( - MakeUnique<SetPassThrough>(processingTrack, listener, true)); + QueueExpectIsPassThrough(processingTrack, listener); processingTrack->SetInputProcessing(listener); processingTrack->GraphImpl()->AppendMessage( MakeUnique<StartInputProcessing>(processingTrack, listener)); @@ -2719,6 +2704,116 @@ TEST(TestAudioTrackGraph, SecondaryOutputDevice) }); WaitFor(primaryStream->OutputVerificationEvent()); } + +// Test when AudioInputProcessing expects clock drift +TEST(TestAudioInputProcessing, ClockDriftExpectation) +{ + MockCubeb* cubeb = new MockCubeb(); + CubebUtils::ForceSetCubebContext(cubeb->AsCubebContext()); + + const TrackRate rate = 44100; + + MediaTrackGraph* graph = MediaTrackGraphImpl::GetInstance( + MediaTrackGraph::SYSTEM_THREAD_DRIVER, + /*Window ID*/ 1, rate, nullptr, GetMainThreadSerialEventTarget()); + + auto createInputProcessing = + [&](CubebUtils::AudioDeviceID aDeviceID, + RefPtr<AudioProcessingTrack>* aProcessingTrack, + RefPtr<AudioInputProcessing>* aInputProcessing) { + /* Create an input track and connect it to a device */ + const int32_t channelCount = 2; + RefPtr processingTrack = AudioProcessingTrack::Create(graph); + RefPtr inputProcessing = new AudioInputProcessing(channelCount); + processingTrack->SetInputProcessing(inputProcessing); + MediaEnginePrefs settings; + settings.mChannels = channelCount; + settings.mAecOn = true; + QueueApplySettings(processingTrack, inputProcessing, settings); + processingTrack->GraphImpl()->AppendMessage( + MakeUnique<StartInputProcessing>(processingTrack, inputProcessing)); + processingTrack->ConnectDeviceInput(aDeviceID, inputProcessing, + PRINCIPAL_HANDLE_NONE); + aProcessingTrack->swap(processingTrack); + aInputProcessing->swap(inputProcessing); + }; + + // Native input, which uses a duplex stream + RefPtr<AudioProcessingTrack> processingTrack1; + RefPtr<AudioInputProcessing> inputProcessing1; + DispatchFunction([&] { + createInputProcessing(nullptr, &processingTrack1, &inputProcessing1); + }); + // Non-native input + const auto* nonNativeInputDeviceID = CubebUtils::AudioDeviceID(1); + RefPtr<AudioProcessingTrack> processingTrack2; + RefPtr<AudioInputProcessing> inputProcessing2; + DispatchFunction([&] { + createInputProcessing(nonNativeInputDeviceID, &processingTrack2, + &inputProcessing2); + processingTrack2->AddAudioOutput(nullptr, nullptr, rate); + }); + + RefPtr<SmartMockCubebStream> primaryStream; + RefPtr<SmartMockCubebStream> nonNativeInputStream; + WaitUntil(cubeb->StreamInitEvent(), + [&](RefPtr<SmartMockCubebStream>&& stream) { + if (stream->OutputChannels() > 0) { + primaryStream = std::move(stream); + return false; + } + nonNativeInputStream = std::move(stream); + return true; + }); + EXPECT_EQ(nonNativeInputStream->GetInputDeviceID(), nonNativeInputDeviceID); + + // Wait until non-native input signal reaches the output, when input + // processing has run and so has been configured. + WaitFor(primaryStream->FramesVerifiedEvent()); + + const void* secondaryOutputDeviceID = CubebUtils::AudioDeviceID(2); + DispatchFunction([&] { + // Check input processing config with output to primary device. + processingTrack1->QueueControlMessageWithNoShutdown([&] { + EXPECT_FALSE(inputProcessing1->HadAECAndDrift()); + EXPECT_TRUE(inputProcessing2->HadAECAndDrift()); + }); + + // Switch output to a secondary device. + processingTrack2->RemoveAudioOutput(nullptr); + processingTrack2->AddAudioOutput(nullptr, secondaryOutputDeviceID, rate); + }); + + RefPtr<SmartMockCubebStream> secondaryOutputStream = + WaitFor(cubeb->StreamInitEvent()); + EXPECT_EQ(secondaryOutputStream->GetOutputDeviceID(), + secondaryOutputDeviceID); + + WaitFor(secondaryOutputStream->FramesVerifiedEvent()); + DispatchFunction([&] { + // Check input processing config with output to secondary device. + processingTrack1->QueueControlMessageWithNoShutdown([&] { + EXPECT_TRUE(inputProcessing1->HadAECAndDrift()); + EXPECT_TRUE(inputProcessing2->HadAECAndDrift()); + }); + }); + + auto destroyInputProcessing = [&](AudioProcessingTrack* aProcessingTrack, + AudioInputProcessing* aInputProcessing) { + aProcessingTrack->GraphImpl()->AppendMessage( + MakeUnique<StopInputProcessing>(aProcessingTrack, aInputProcessing)); + aProcessingTrack->DisconnectDeviceInput(); + aProcessingTrack->Destroy(); + }; + + DispatchFunction([&] { + // Clean up + destroyInputProcessing(processingTrack1, inputProcessing1); + destroyInputProcessing(processingTrack2, inputProcessing2); + }); + // Wait for stream stop to ensure that expectations have been checked. + WaitFor(nonNativeInputStream->OutputVerificationEvent()); +} #endif // MOZ_WEBRTC #undef Invoke diff --git a/dom/media/gtest/TestDeviceInputTrack.cpp b/dom/media/gtest/TestDeviceInputTrack.cpp index 6eb8c08774..14b5227f9d 100644 --- a/dom/media/gtest/TestDeviceInputTrack.cpp +++ b/dom/media/gtest/TestDeviceInputTrack.cpp @@ -150,16 +150,16 @@ TEST_F(TestDeviceInputTrack, DeviceInputConsumerTrack) { RefPtr<TestDeviceInputConsumerTrack> track1 = TestDeviceInputConsumerTrack::Create(mGraph); track1->ConnectDeviceInput(device1, listener1.get(), testPrincipal); - EXPECT_TRUE(track1->ConnectToNativeDevice()); - EXPECT_FALSE(track1->ConnectToNonNativeDevice()); + EXPECT_TRUE(track1->ConnectedToNativeDevice()); + EXPECT_FALSE(track1->ConnectedToNonNativeDevice()); const CubebUtils::AudioDeviceID device2 = (void*)2; RefPtr<TestAudioDataListener> listener2 = new TestAudioDataListener(2, false); RefPtr<TestDeviceInputConsumerTrack> track2 = TestDeviceInputConsumerTrack::Create(mGraph); track2->ConnectDeviceInput(device2, listener2.get(), testPrincipal); - EXPECT_FALSE(track2->ConnectToNativeDevice()); - EXPECT_TRUE(track2->ConnectToNonNativeDevice()); + EXPECT_FALSE(track2->ConnectedToNativeDevice()); + EXPECT_TRUE(track2->ConnectedToNonNativeDevice()); track2->Destroy(); mGraph->RemoveTrackGraphThread(track2); diff --git a/dom/media/gtest/TestMediaDataEncoder.cpp b/dom/media/gtest/TestMediaDataEncoder.cpp index 27a6b7cd07..39c92fb19c 100644 --- a/dom/media/gtest/TestMediaDataEncoder.cpp +++ b/dom/media/gtest/TestMediaDataEncoder.cpp @@ -33,7 +33,7 @@ #define FRAME_RATE 30 #define FRAME_DURATION (1000000 / FRAME_RATE) #define BIT_RATE (1000 * 1000) // 1Mbps -#define BIT_RATE_MODE MediaDataEncoder::BitrateMode::Variable +#define BIT_RATE_MODE BitrateMode::Variable #define KEYFRAME_INTERVAL FRAME_RATE // 1 keyframe per second using namespace mozilla; @@ -156,9 +156,8 @@ class MediaDataEncoderTest : public testing::Test { template <typename T> already_AddRefed<MediaDataEncoder> CreateVideoEncoder( - CodecType aCodec, MediaDataEncoder::Usage aUsage, - MediaDataEncoder::PixelFormat aPixelFormat, int32_t aWidth, int32_t aHeight, - MediaDataEncoder::ScalabilityMode aScalabilityMode, + CodecType aCodec, Usage aUsage, dom::ImageBitmapFormat aPixelFormat, + int32_t aWidth, int32_t aHeight, ScalabilityMode aScalabilityMode, const Maybe<T>& aSpecific) { RefPtr<PEMFactory> f(new PEMFactory()); @@ -171,13 +170,7 @@ already_AddRefed<MediaDataEncoder> CreateVideoEncoder( "TestMediaDataEncoder")); RefPtr<MediaDataEncoder> e; -#ifdef MOZ_WIDGET_ANDROID - const MediaDataEncoder::HardwarePreference pref = - MediaDataEncoder::HardwarePreference::None; -#else - const MediaDataEncoder::HardwarePreference pref = - MediaDataEncoder::HardwarePreference::None; -#endif + const HardwarePreference pref = HardwarePreference::None; e = f->CreateEncoder( EncoderConfig(aCodec, gfx::IntSize{aWidth, aHeight}, aUsage, aPixelFormat, aPixelFormat, FRAME_RATE /* FPS */, @@ -190,12 +183,10 @@ already_AddRefed<MediaDataEncoder> CreateVideoEncoder( } static already_AddRefed<MediaDataEncoder> CreateH264Encoder( - MediaDataEncoder::Usage aUsage = MediaDataEncoder::Usage::Realtime, - MediaDataEncoder::PixelFormat aPixelFormat = - MediaDataEncoder::PixelFormat::YUV420P, + Usage aUsage = Usage::Realtime, + dom::ImageBitmapFormat aPixelFormat = dom::ImageBitmapFormat::YUV420P, int32_t aWidth = WIDTH, int32_t aHeight = HEIGHT, - MediaDataEncoder::ScalabilityMode aScalabilityMode = - MediaDataEncoder::ScalabilityMode::None, + ScalabilityMode aScalabilityMode = ScalabilityMode::None, const Maybe<H264Specific>& aSpecific = Some(kH264SpecificAnnexB)) { return CreateVideoEncoder(CodecType::H264, aUsage, aPixelFormat, aWidth, aHeight, aScalabilityMode, aSpecific); @@ -234,10 +225,7 @@ static bool EnsureInit(const RefPtr<MediaDataEncoder>& aEncoder) { bool succeeded; media::Await( GetMediaThreadPool(MediaThreadType::SUPERVISOR), aEncoder->Init(), - [&succeeded](TrackInfo::TrackType t) { - EXPECT_EQ(TrackInfo::TrackType::kVideoTrack, t); - succeeded = true; - }, + [&succeeded](bool) { succeeded = true; }, [&succeeded](const MediaResult& r) { succeeded = false; }); return succeeded; } @@ -246,9 +234,8 @@ TEST_F(MediaDataEncoderTest, H264Inits) { RUN_IF_SUPPORTED(CodecType::H264, []() { // w/o codec specific: should fail for h264. RefPtr<MediaDataEncoder> e = - CreateH264Encoder(MediaDataEncoder::Usage::Realtime, - MediaDataEncoder::PixelFormat::YUV420P, WIDTH, HEIGHT, - MediaDataEncoder::ScalabilityMode::None, Nothing()); + CreateH264Encoder(Usage::Realtime, dom::ImageBitmapFormat::YUV420P, + WIDTH, HEIGHT, ScalabilityMode::None, Nothing()); EXPECT_FALSE(e); // w/ codec specific @@ -319,9 +306,8 @@ TEST_F(MediaDataEncoderTest, H264Encodes) { WaitForShutdown(e); // Encode one frame and output in avcC format. - e = CreateH264Encoder(MediaDataEncoder::Usage::Record, - MediaDataEncoder::PixelFormat::YUV420P, WIDTH, HEIGHT, - MediaDataEncoder::ScalabilityMode::None, + e = CreateH264Encoder(Usage::Record, dom::ImageBitmapFormat::YUV420P, WIDTH, + HEIGHT, ScalabilityMode::None, Some(kH264SpecificAVCC)); EnsureInit(e); output = Encode(e, NUM_FRAMES, mData); @@ -349,22 +335,19 @@ TEST_F(MediaDataEncoderTest, H264Duration) { TEST_F(MediaDataEncoderTest, InvalidSize) { RUN_IF_SUPPORTED(CodecType::H264, []() { - RefPtr<MediaDataEncoder> e0x0 = CreateH264Encoder( - MediaDataEncoder::Usage::Realtime, - MediaDataEncoder::PixelFormat::YUV420P, 0, 0, - MediaDataEncoder::ScalabilityMode::None, Some(kH264SpecificAnnexB)); + RefPtr<MediaDataEncoder> e0x0 = + CreateH264Encoder(Usage::Realtime, dom::ImageBitmapFormat::YUV420P, 0, + 0, ScalabilityMode::None, Some(kH264SpecificAnnexB)); EXPECT_EQ(e0x0, nullptr); - RefPtr<MediaDataEncoder> e0x1 = CreateH264Encoder( - MediaDataEncoder::Usage::Realtime, - MediaDataEncoder::PixelFormat::YUV420P, 0, 1, - MediaDataEncoder::ScalabilityMode::None, Some(kH264SpecificAnnexB)); + RefPtr<MediaDataEncoder> e0x1 = + CreateH264Encoder(Usage::Realtime, dom::ImageBitmapFormat::YUV420P, 0, + 1, ScalabilityMode::None, Some(kH264SpecificAnnexB)); EXPECT_EQ(e0x1, nullptr); - RefPtr<MediaDataEncoder> e1x0 = CreateH264Encoder( - MediaDataEncoder::Usage::Realtime, - MediaDataEncoder::PixelFormat::YUV420P, 1, 0, - MediaDataEncoder::ScalabilityMode::None, Some(kH264SpecificAnnexB)); + RefPtr<MediaDataEncoder> e1x0 = + CreateH264Encoder(Usage::Realtime, dom::ImageBitmapFormat::YUV420P, 1, + 0, ScalabilityMode::None, Some(kH264SpecificAnnexB)); EXPECT_EQ(e1x0, nullptr); }); } @@ -372,10 +355,9 @@ TEST_F(MediaDataEncoderTest, InvalidSize) { #ifdef MOZ_WIDGET_ANDROID TEST_F(MediaDataEncoderTest, AndroidNotSupportedSize) { RUN_IF_SUPPORTED(CodecType::H264, []() { - RefPtr<MediaDataEncoder> e = CreateH264Encoder( - MediaDataEncoder::Usage::Realtime, - MediaDataEncoder::PixelFormat::YUV420P, 1, 1, - MediaDataEncoder::ScalabilityMode::None, Some(kH264SpecificAnnexB)); + RefPtr<MediaDataEncoder> e = + CreateH264Encoder(Usage::Realtime, dom::ImageBitmapFormat::YUV420P, 1, + 1, ScalabilityMode::None, Some(kH264SpecificAnnexB)); EXPECT_NE(e, nullptr); EXPECT_FALSE(EnsureInit(e)); }); @@ -387,9 +369,8 @@ TEST_F(MediaDataEncoderTest, H264AVCC) { RUN_IF_SUPPORTED(CodecType::H264, [this]() { // Encod frames in avcC format. RefPtr<MediaDataEncoder> e = CreateH264Encoder( - MediaDataEncoder::Usage::Record, MediaDataEncoder::PixelFormat::YUV420P, - WIDTH, HEIGHT, MediaDataEncoder::ScalabilityMode::None, - Some(kH264SpecificAVCC)); + Usage::Record, dom::ImageBitmapFormat::YUV420P, WIDTH, HEIGHT, + ScalabilityMode::None, Some(kH264SpecificAVCC)); EnsureInit(e); MediaDataEncoder::EncodedData output = Encode(e, NUM_FRAMES, mData); EXPECT_EQ(output.Length(), NUM_FRAMES); @@ -412,24 +393,20 @@ TEST_F(MediaDataEncoderTest, H264AVCC) { #endif static already_AddRefed<MediaDataEncoder> CreateVP8Encoder( - MediaDataEncoder::Usage aUsage = MediaDataEncoder::Usage::Realtime, - MediaDataEncoder::PixelFormat aPixelFormat = - MediaDataEncoder::PixelFormat::YUV420P, + Usage aUsage = Usage::Realtime, + dom::ImageBitmapFormat aPixelFormat = dom::ImageBitmapFormat::YUV420P, int32_t aWidth = WIDTH, int32_t aHeight = HEIGHT, - MediaDataEncoder::ScalabilityMode aScalabilityMode = - MediaDataEncoder::ScalabilityMode::None, + ScalabilityMode aScalabilityMode = ScalabilityMode::None, const Maybe<VP8Specific>& aSpecific = Some(VP8Specific())) { return CreateVideoEncoder(CodecType::VP8, aUsage, aPixelFormat, aWidth, aHeight, aScalabilityMode, aSpecific); } static already_AddRefed<MediaDataEncoder> CreateVP9Encoder( - MediaDataEncoder::Usage aUsage = MediaDataEncoder::Usage::Realtime, - MediaDataEncoder::PixelFormat aPixelFormat = - MediaDataEncoder::PixelFormat::YUV420P, + Usage aUsage = Usage::Realtime, + dom::ImageBitmapFormat aPixelFormat = dom::ImageBitmapFormat::YUV420P, int32_t aWidth = WIDTH, int32_t aHeight = HEIGHT, - MediaDataEncoder::ScalabilityMode aScalabilityMode = - MediaDataEncoder::ScalabilityMode::None, + ScalabilityMode aScalabilityMode = ScalabilityMode::None, const Maybe<VP9Specific>& aSpecific = Some(VP9Specific())) { return CreateVideoEncoder(CodecType::VP9, aUsage, aPixelFormat, aWidth, aHeight, aScalabilityMode, aSpecific); @@ -447,9 +424,8 @@ TEST_F(MediaDataEncoderTest, VP8Inits) { RUN_IF_SUPPORTED(CodecType::VP8, []() { // w/o codec specific. RefPtr<MediaDataEncoder> e = - CreateVP8Encoder(MediaDataEncoder::Usage::Realtime, - MediaDataEncoder::PixelFormat::YUV420P, WIDTH, HEIGHT, - MediaDataEncoder::ScalabilityMode::None, Nothing()); + CreateVP8Encoder(Usage::Realtime, dom::ImageBitmapFormat::YUV420P, + WIDTH, HEIGHT, ScalabilityMode::None, Nothing()); EXPECT_TRUE(EnsureInit(e)); WaitForShutdown(e); @@ -551,10 +527,9 @@ TEST_F(MediaDataEncoderTest, VP8EncodeWithScalabilityModeL1T2) { false, /* mAutoResize */ false /* mFrameDropping */ ); - RefPtr<MediaDataEncoder> e = CreateVP8Encoder( - MediaDataEncoder::Usage::Realtime, - MediaDataEncoder::PixelFormat::YUV420P, WIDTH, HEIGHT, - MediaDataEncoder::ScalabilityMode::L1T2, Some(specific)); + RefPtr<MediaDataEncoder> e = + CreateVP8Encoder(Usage::Realtime, dom::ImageBitmapFormat::YUV420P, + WIDTH, HEIGHT, ScalabilityMode::L1T2, Some(specific)); EnsureInit(e); const nsTArray<uint8_t> pattern({0, 1}); @@ -580,10 +555,9 @@ TEST_F(MediaDataEncoderTest, VP8EncodeWithScalabilityModeL1T3) { false, /* mAutoResize */ false /* mFrameDropping */ ); - RefPtr<MediaDataEncoder> e = CreateVP8Encoder( - MediaDataEncoder::Usage::Realtime, - MediaDataEncoder::PixelFormat::YUV420P, WIDTH, HEIGHT, - MediaDataEncoder::ScalabilityMode::L1T3, Some(specific)); + RefPtr<MediaDataEncoder> e = + CreateVP8Encoder(Usage::Realtime, dom::ImageBitmapFormat::YUV420P, + WIDTH, HEIGHT, ScalabilityMode::L1T3, Some(specific)); EnsureInit(e); const nsTArray<uint8_t> pattern({0, 2, 1, 2}); @@ -613,9 +587,8 @@ TEST_F(MediaDataEncoderTest, VP9Inits) { RUN_IF_SUPPORTED(CodecType::VP9, []() { // w/o codec specific. RefPtr<MediaDataEncoder> e = - CreateVP9Encoder(MediaDataEncoder::Usage::Realtime, - MediaDataEncoder::PixelFormat::YUV420P, WIDTH, HEIGHT, - MediaDataEncoder::ScalabilityMode::None, Nothing()); + CreateVP9Encoder(Usage::Realtime, dom::ImageBitmapFormat::YUV420P, + WIDTH, HEIGHT, ScalabilityMode::None, Nothing()); EXPECT_TRUE(EnsureInit(e)); WaitForShutdown(e); @@ -719,10 +692,9 @@ TEST_F(MediaDataEncoderTest, VP9EncodeWithScalabilityModeL1T2) { false /* mFlexible */ ); - RefPtr<MediaDataEncoder> e = CreateVP9Encoder( - MediaDataEncoder::Usage::Realtime, - MediaDataEncoder::PixelFormat::YUV420P, WIDTH, HEIGHT, - MediaDataEncoder::ScalabilityMode::L1T2, Some(specific)); + RefPtr<MediaDataEncoder> e = + CreateVP9Encoder(Usage::Realtime, dom::ImageBitmapFormat::YUV420P, + WIDTH, HEIGHT, ScalabilityMode::L1T2, Some(specific)); EnsureInit(e); const nsTArray<uint8_t> pattern({0, 1}); @@ -751,10 +723,9 @@ TEST_F(MediaDataEncoderTest, VP9EncodeWithScalabilityModeL1T3) { false /* mFlexible */ ); - RefPtr<MediaDataEncoder> e = CreateVP9Encoder( - MediaDataEncoder::Usage::Realtime, - MediaDataEncoder::PixelFormat::YUV420P, WIDTH, HEIGHT, - MediaDataEncoder::ScalabilityMode::L1T3, Some(specific)); + RefPtr<MediaDataEncoder> e = + CreateVP9Encoder(Usage::Realtime, dom::ImageBitmapFormat::YUV420P, + WIDTH, HEIGHT, ScalabilityMode::L1T3, Some(specific)); EnsureInit(e); const nsTArray<uint8_t> pattern({0, 2, 1, 2}); |