Adding upstream version 115.8.0esr.upstream/115.8.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 225 insertions, 0 deletions

diff --git a/dom/media/webaudio/AudioNodeExternalInputTrack.cpp b/dom/media/webaudio/AudioNodeExternalInputTrack.cpp
new file mode 100644
index 0000000000..2142752d39
--- /dev/null
+++ b/dom/media/webaudio/AudioNodeExternalInputTrack.cpp
@@ -0,0 +1,225 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-*/
+/* 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/. */
+
+#include "AlignedTArray.h"
+#include "AlignmentUtils.h"
+#include "AudioNodeEngine.h"
+#include "AudioNodeExternalInputTrack.h"
+#include "AudioChannelFormat.h"
+#include "mozilla/dom/MediaStreamAudioSourceNode.h"
+
+using namespace mozilla::dom;
+
+namespace mozilla {
+
+AudioNodeExternalInputTrack::AudioNodeExternalInputTrack(
+    AudioNodeEngine* aEngine, TrackRate aSampleRate)
+    : AudioNodeTrack(aEngine, NO_TRACK_FLAGS, aSampleRate) {
+  MOZ_COUNT_CTOR(AudioNodeExternalInputTrack);
+}
+
+AudioNodeExternalInputTrack::~AudioNodeExternalInputTrack() {
+  MOZ_COUNT_DTOR(AudioNodeExternalInputTrack);
+}
+
+/* static */
+already_AddRefed<AudioNodeExternalInputTrack>
+AudioNodeExternalInputTrack::Create(MediaTrackGraph* aGraph,
+                                    AudioNodeEngine* aEngine) {
+  AudioContext* ctx = aEngine->NodeMainThread()->Context();
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aGraph == ctx->Graph());
+
+  RefPtr<AudioNodeExternalInputTrack> track =
+      new AudioNodeExternalInputTrack(aEngine, aGraph->GraphRate());
+  track->mSuspendedCount += ctx->ShouldSuspendNewTrack();
+  aGraph->AddTrack(track);
+  return track.forget();
+}
+
+/**
+ * Copies the data in aInput to aOffsetInBlock within aBlock.
+ * aBlock must have been allocated with AllocateInputBlock and have a channel
+ * count that's a superset of the channels in aInput.
+ */
+template <typename T>
+static void CopyChunkToBlock(AudioChunk& aInput, AudioBlock* aBlock,
+                             uint32_t aOffsetInBlock) {
+  uint32_t blockChannels = aBlock->ChannelCount();
+  AutoTArray<const T*, 2> channels;
+  if (aInput.IsNull()) {
+    channels.SetLength(blockChannels);
+    PodZero(channels.Elements(), blockChannels);
+  } else {
+    const nsTArray<const T*>& inputChannels = aInput.ChannelData<T>();
+    channels.SetLength(inputChannels.Length());
+    PodCopy(channels.Elements(), inputChannels.Elements(), channels.Length());
+    if (channels.Length() != blockChannels) {
+      // We only need to upmix here because aBlock's channel count has been
+      // chosen to be a superset of the channel count of every chunk.
+      AudioChannelsUpMix(&channels, blockChannels, static_cast<T*>(nullptr));
+    }
+  }
+
+  for (uint32_t c = 0; c < blockChannels; ++c) {
+    float* outputData = aBlock->ChannelFloatsForWrite(c) + aOffsetInBlock;
+    if (channels[c]) {
+      ConvertAudioSamplesWithScale(channels[c], outputData,
+                                   aInput.GetDuration(), aInput.mVolume);
+    } else {
+      PodZero(outputData, aInput.GetDuration());
+    }
+  }
+}
+
+/**
+ * Converts the data in aSegment to a single chunk aBlock. aSegment must have
+ * duration WEBAUDIO_BLOCK_SIZE. aFallbackChannelCount is a superset of the
+ * channels in every chunk of aSegment. aBlock must be float format or null.
+ */
+static void ConvertSegmentToAudioBlock(AudioSegment* aSegment,
+                                       AudioBlock* aBlock,
+                                       int32_t aFallbackChannelCount) {
+  NS_ASSERTION(aSegment->GetDuration() == WEBAUDIO_BLOCK_SIZE,
+               "Bad segment duration");
+
+  {
+    AudioSegment::ChunkIterator ci(*aSegment);
+    NS_ASSERTION(!ci.IsEnded(), "Should be at least one chunk!");
+    if (ci->GetDuration() == WEBAUDIO_BLOCK_SIZE &&
+        (ci->IsNull() || ci->mBufferFormat == AUDIO_FORMAT_FLOAT32)) {
+      bool aligned = true;
+      for (size_t i = 0; i < ci->mChannelData.Length(); ++i) {
+        if (!IS_ALIGNED16(ci->mChannelData[i])) {
+          aligned = false;
+          break;
+        }
+      }
+
+      // Return this chunk directly to avoid copying data.
+      if (aligned) {
+        *aBlock = *ci;
+        return;
+      }
+    }
+  }
+
+  aBlock->AllocateChannels(aFallbackChannelCount);
+
+  uint32_t duration = 0;
+  for (AudioSegment::ChunkIterator ci(*aSegment); !ci.IsEnded(); ci.Next()) {
+    switch (ci->mBufferFormat) {
+      case AUDIO_FORMAT_S16: {
+        CopyChunkToBlock<int16_t>(*ci, aBlock, duration);
+        break;
+      }
+      case AUDIO_FORMAT_FLOAT32: {
+        CopyChunkToBlock<float>(*ci, aBlock, duration);
+        break;
+      }
+      case AUDIO_FORMAT_SILENCE: {
+        // The actual type of the sample does not matter here, but we still need
+        // to send some audio to the graph.
+        CopyChunkToBlock<float>(*ci, aBlock, duration);
+        break;
+      }
+    }
+    duration += ci->GetDuration();
+  }
+}
+
+void AudioNodeExternalInputTrack::ProcessInput(GraphTime aFrom, GraphTime aTo,
+                                               uint32_t aFlags) {
+  // According to spec, number of outputs is always 1.
+  MOZ_ASSERT(mLastChunks.Length() == 1);
+
+  // GC stuff can result in our input track being destroyed before this track.
+  // Handle that.
+  if (!IsEnabled() || mInputs.IsEmpty() || mPassThrough) {
+    mLastChunks[0].SetNull(WEBAUDIO_BLOCK_SIZE);
+    return;
+  }
+
+  MOZ_ASSERT(mInputs.Length() == 1);
+
+  MediaTrack* source = mInputs[0]->GetSource();
+  AutoTArray<AudioSegment, 1> audioSegments;
+  uint32_t inputChannels = 0;
+
+  MOZ_ASSERT(source->GetData()->GetType() == MediaSegment::AUDIO,
+             "AudioNodeExternalInputTrack shouldn't have a video input");
+
+  const AudioSegment& inputSegment =
+      *mInputs[0]->GetSource()->GetData<AudioSegment>();
+  if (!inputSegment.IsNull()) {
+    AudioSegment& segment = *audioSegments.AppendElement();
+    GraphTime next;
+    for (GraphTime t = aFrom; t < aTo; t = next) {
+      MediaInputPort::InputInterval interval =
+          MediaInputPort::GetNextInputInterval(mInputs[0], t);
+      interval.mEnd = std::min(interval.mEnd, aTo);
+      if (interval.mStart >= interval.mEnd) {
+        break;
+      }
+      next = interval.mEnd;
+
+      // We know this track does not block during the processing interval ---
+      // we're not finished, we don't underrun, and we're not suspended.
+      TrackTime outputStart = GraphTimeToTrackTime(interval.mStart);
+      TrackTime outputEnd = GraphTimeToTrackTime(interval.mEnd);
+      TrackTime ticks = outputEnd - outputStart;
+
+      if (interval.mInputIsBlocked) {
+        segment.AppendNullData(ticks);
+      } else {
+        // The input track is not blocked in this interval, so no need to call
+        // GraphTimeToTrackTimeWithBlocking.
+        TrackTime inputStart =
+            std::min(inputSegment.GetDuration(),
+                     source->GraphTimeToTrackTime(interval.mStart));
+        TrackTime inputEnd =
+            std::min(inputSegment.GetDuration(),
+                     source->GraphTimeToTrackTime(interval.mEnd));
+
+        segment.AppendSlice(inputSegment, inputStart, inputEnd);
+        // Pad if we're looking past the end of the track
+        segment.AppendNullData(ticks - (inputEnd - inputStart));
+      }
+    }
+
+    for (AudioSegment::ChunkIterator iter(segment); !iter.IsEnded();
+         iter.Next()) {
+      inputChannels =
+          GetAudioChannelsSuperset(inputChannels, iter->ChannelCount());
+    }
+  }
+
+  uint32_t accumulateIndex = 0;
+  if (inputChannels) {
+    DownmixBufferType downmixBuffer;
+    ASSERT_ALIGNED16(downmixBuffer.Elements());
+    for (auto& audioSegment : audioSegments) {
+      AudioBlock tmpChunk;
+      ConvertSegmentToAudioBlock(&audioSegment, &tmpChunk, inputChannels);
+      if (!tmpChunk.IsNull()) {
+        if (accumulateIndex == 0) {
+          mLastChunks[0].AllocateChannels(inputChannels);
+        }
+        AccumulateInputChunk(accumulateIndex, tmpChunk, &mLastChunks[0],
+                             &downmixBuffer);
+        accumulateIndex++;
+      }
+    }
+  }
+  if (accumulateIndex == 0) {
+    mLastChunks[0].SetNull(WEBAUDIO_BLOCK_SIZE);
+  }
+}
+
+bool AudioNodeExternalInputTrack::IsEnabled() {
+  return ((MediaStreamAudioSourceNodeEngine*)Engine())->IsEnabled();
+}
+
+}  // namespace mozilla