Bug 1978232 - Add batch endoing API to WMFMediaDataEncoder r=media-playback-reviewers,jolin

This patch introduces a new API in `MediaDataEncoder` for batch encoding and
implement it for `WMFMediaDataEncoder`.

Differential Revision: https://phabricator.services.mozilla.com/D261493

Author: ChunMinChang

dom/media/ipc/RemoteMediaDataEncoderChild.cpp

@@ -123,6 +123,7 @@ void RemoteMediaDataEncoderChild::DoSendInit() {
 
         self->mIsHardwareAccelerated = initResponse.hardware();
         self->mHardwareAcceleratedReason = initResponse.hardwareReason();
+        // TODO: Get batch-encoding capability.
         self->mInitPromise.ResolveIfExists(true, __func__);
       },
       [self = RefPtr{this}](const mozilla::ipc::ResponseRejectReason& aReason) {

dom/media/ipc/RemoteMediaDataEncoderParent.cpp

@@ -72,6 +72,7 @@ IPCResult RemoteMediaDataEncoderParent::RecvInit(InitResolver&& aResolver) {
           return;
         }
 
+        // TODO: Pass batch-encoding capability.
         nsCString hardwareReason;
         bool hardware = encoder->IsHardwareAccelerated(hardwareReason);
         resolver(EncodeInitCompletionIPDL{encoder->GetDescriptionName(),

dom/media/platforms/PlatformEncoderModule.h

@@ -86,6 +86,17 @@ class MediaDataEncoder {
   // or empty when there is none available yet.
   virtual RefPtr<EncodePromise> Encode(const MediaData* aSample) = 0;
 
+  // Inserts a batch of samples into the encoder's encode pipeline. The
+  // EncodePromise it returns will be resolved with already encoded MediaRawData
+  // at the moment, or empty when there is none available yet.
+  virtual RefPtr<EncodePromise> Encode(nsTArray<RefPtr<MediaData>>&& aSamples) {
+    MOZ_ASSERT_UNREACHABLE("Encode samples in a batch is not implemented");
+    return EncodePromise::CreateAndReject(
+        MediaResult(NS_ERROR_NOT_IMPLEMENTED,
+                    "Encode samples in a batch is not implemented"),
+        __func__);
+  }
+
   // Attempt to reconfigure the encoder on the fly. This can fail if the
   // underlying PEM doesn't support this type of reconfiguration.
   virtual RefPtr<ReconfigurationPromise> Reconfigure(

dom/media/platforms/wmf/WMFMediaDataEncoder.cpp

@@ -51,6 +51,20 @@ RefPtr<EncodePromise> WMFMediaDataEncoder::Encode(const MediaData* aSample) {
       mTaskQueue, this, __func__, &WMFMediaDataEncoder::ProcessEncode,
       std::move(sample));
 }
+RefPtr<EncodePromise> WMFMediaDataEncoder::Encode(
+    nsTArray<RefPtr<MediaData>>&& aSamples) {
+  WMF_ENC_LOGD("Encode: num of samples=%zu", aSamples.Length());
+  MOZ_ASSERT(!aSamples.IsEmpty());
+
+  nsTArray<RefPtr<const VideoData>> videoSamples;
+  for (auto& sample : aSamples) {
+    videoSamples.AppendElement(sample->As<const VideoData>());
+  }
+
+  return InvokeAsync(mTaskQueue, this, __func__,
+                     &WMFMediaDataEncoder::ProcessEncodeBatch,
+                     std::move(videoSamples));
+}
 RefPtr<EncodePromise> WMFMediaDataEncoder::Drain() {
   WMF_ENC_LOGD("Drain");
   return InvokeAsync(mTaskQueue, this, __func__,
@@ -249,6 +263,55 @@ RefPtr<EncodePromise> WMFMediaDataEncoder::ProcessEncode(
   return p;
 }
 
+RefPtr<EncodePromise> WMFMediaDataEncoder::ProcessEncodeBatch(
+    nsTArray<RefPtr<const VideoData>>&& aSamples) {
+  AssertOnTaskQueue();
+  MOZ_ASSERT(mEncoder);
+  MOZ_ASSERT(!aSamples.IsEmpty());
+  MOZ_ASSERT(mEncodePromise.IsEmpty());
+  MOZ_ASSERT(!mEncodeRequest.Exists());
+
+  WMF_ENC_LOGD("ProcessEncodeBatch: num of samples=%zu", aSamples.Length());
+
+  nsTArray<MFTEncoder::InputSample> inputs;
+  for (auto& sample : aSamples) {
+    RefPtr<IMFSample> nv12 = ConvertToNV12InputSample(std::move(sample));
+    if (!nv12) {
+      WMF_ENC_LOGE(
+          "failed to convert samples(ts=%s duration=%s) into NV12 format",
+          sample->mTime.ToString().get(), sample->mDuration.ToString().get());
+      return EncodePromise::CreateAndReject(
+          MediaResult(
+              NS_ERROR_DOM_MEDIA_FATAL_ERR,
+              RESULT_DETAIL("Failed to convert sample into NV12 format")),
+          __func__);
+    }
+    inputs.AppendElement(MFTEncoder::InputSample{
+        .mSample = std::move(nv12), .mKeyFrameRequested = sample->mKeyframe});
+  }
+
+  RefPtr<EncodePromise> p = mEncodePromise.Ensure(__func__);
+
+  mEncoder->Encode(std::move(inputs))
+      ->Then(
+          GetCurrentSerialEventTarget(), __func__,
+          [self = RefPtr<WMFMediaDataEncoder>(this)](
+              MFTEncoder::EncodedData&& aOutput) {
+            self->mEncodeRequest.Complete();
+            self->mEncodePromise.Resolve(
+                self->ProcessOutputSamples(std::move(aOutput)), __func__);
+          },
+          [self =
+               RefPtr<WMFMediaDataEncoder>(this)](const MediaResult& aError) {
+            WMF_ENC_SLOGE("Encode failed: %s", aError.Description().get());
+            self->mEncodeRequest.Complete();
+            self->mEncodePromise.Reject(aError, __func__);
+          })
+      ->Track(mEncodeRequest);
+
+  return p;
+}
+
 RefPtr<EncodePromise> WMFMediaDataEncoder::ProcessDrain() {
   AssertOnTaskQueue();
   MOZ_ASSERT(mEncoder);

dom/media/platforms/wmf/WMFMediaDataEncoder.h

@@ -26,6 +26,7 @@ class WMFMediaDataEncoder final : public MediaDataEncoder {
 
   RefPtr<InitPromise> Init() override;
   RefPtr<EncodePromise> Encode(const MediaData* aSample) override;
+  RefPtr<EncodePromise> Encode(nsTArray<RefPtr<MediaData>>&& aSamples) override;
   RefPtr<EncodePromise> Drain() override;
   RefPtr<ShutdownPromise> Shutdown() override;
   RefPtr<GenericPromise> SetBitrate(uint32_t aBitsPerSec) override;
@@ -74,6 +75,8 @@ class WMFMediaDataEncoder final : public MediaDataEncoder {
   void SetConfigData(const nsTArray<UINT8>& aHeader);
 
   RefPtr<EncodePromise> ProcessEncode(RefPtr<const VideoData>&& aSample);
+  RefPtr<EncodePromise> ProcessEncodeBatch(
+      nsTArray<RefPtr<const VideoData>>&& aSamples);
   RefPtr<EncodePromise> ProcessDrain();
 
   already_AddRefed<IMFSample> ConvertToNV12InputSample(
@@ -101,6 +104,8 @@ class WMFMediaDataEncoder final : public MediaDataEncoder {
   // Can be accessed on any thread, but only written on during init.
   Atomic<bool> mIsHardwareAccelerated;
 
+  // Both Encode and EncodeBatch share mEncodePromise and mEncodeRequest, as
+  // concurrent calls are not allowed.
   MozPromiseHolder<EncodePromise> mEncodePromise;
   MozPromiseRequestHolder<MFTEncoder::EncodePromise> mEncodeRequest;