Adding upstream version 115.7.0esr.upstream/115.7.0esr

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

1 files changed, 754 insertions, 0 deletions

diff --git a/dom/media/platforms/wmf/MFTEncoder.cpp b/dom/media/platforms/wmf/MFTEncoder.cpp
new file mode 100644
index 0000000000..410da2733c
--- /dev/null
+++ b/dom/media/platforms/wmf/MFTEncoder.cpp
@@ -0,0 +1,754 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "MFTEncoder.h"
+#include "mozilla/Logging.h"
+#include "mozilla/WindowsProcessMitigations.h"
+#include "mozilla/StaticPrefs_media.h"
+#include "mozilla/mscom/Utils.h"
+#include "WMFUtils.h"
+
+// Missing from MinGW.
+#ifndef CODECAPI_AVEncAdaptiveMode
+#  define STATIC_CODECAPI_AVEncAdaptiveMode \
+    0x4419b185, 0xda1f, 0x4f53, 0xbc, 0x76, 0x9, 0x7d, 0xc, 0x1e, 0xfb, 0x1e
+DEFINE_CODECAPI_GUID(AVEncAdaptiveMode, "4419b185-da1f-4f53-bc76-097d0c1efb1e",
+                     0x4419b185, 0xda1f, 0x4f53, 0xbc, 0x76, 0x9, 0x7d, 0xc,
+                     0x1e, 0xfb, 0x1e)
+#  define CODECAPI_AVEncAdaptiveMode \
+    DEFINE_CODECAPI_GUIDNAMED(AVEncAdaptiveMode)
+#endif
+#ifndef MF_E_NO_EVENTS_AVAILABLE
+#  define MF_E_NO_EVENTS_AVAILABLE _HRESULT_TYPEDEF_(0xC00D3E80L)
+#endif
+
+#define MFT_ENC_LOGD(arg, ...)                        \
+  MOZ_LOG(mozilla::sPEMLog, mozilla::LogLevel::Debug, \
+          ("MFTEncoder(0x%p)::%s: " arg, this, __func__, ##__VA_ARGS__))
+#define MFT_ENC_LOGE(arg, ...)                        \
+  MOZ_LOG(mozilla::sPEMLog, mozilla::LogLevel::Error, \
+          ("MFTEncoder(0x%p)::%s: " arg, this, __func__, ##__VA_ARGS__))
+#define MFT_ENC_SLOGD(arg, ...)                       \
+  MOZ_LOG(mozilla::sPEMLog, mozilla::LogLevel::Debug, \
+          ("MFTEncoder::%s: " arg, __func__, ##__VA_ARGS__))
+#define MFT_ENC_SLOGE(arg, ...)                       \
+  MOZ_LOG(mozilla::sPEMLog, mozilla::LogLevel::Error, \
+          ("MFTEncoder::%s: " arg, __func__, ##__VA_ARGS__))
+
+namespace mozilla {
+extern LazyLogModule sPEMLog;
+
+static const char* ErrorStr(HRESULT hr) {
+  switch (hr) {
+    case S_OK:
+      return "OK";
+    case MF_E_INVALIDMEDIATYPE:
+      return "INVALIDMEDIATYPE";
+    case MF_E_INVALIDSTREAMNUMBER:
+      return "INVALIDSTREAMNUMBER";
+    case MF_E_INVALIDTYPE:
+      return "INVALIDTYPE";
+    case MF_E_TRANSFORM_CANNOT_CHANGE_MEDIATYPE_WHILE_PROCESSING:
+      return "TRANSFORM_PROCESSING";
+    case MF_E_TRANSFORM_TYPE_NOT_SET:
+      return "TRANSFORM_TYPE_NO_SET";
+    case MF_E_UNSUPPORTED_D3D_TYPE:
+      return "UNSUPPORTED_D3D_TYPE";
+    case E_INVALIDARG:
+      return "INVALIDARG";
+    case MF_E_NO_SAMPLE_DURATION:
+      return "NO_SAMPLE_DURATION";
+    case MF_E_NO_SAMPLE_TIMESTAMP:
+      return "NO_SAMPLE_TIMESTAMP";
+    case MF_E_NOTACCEPTING:
+      return "NOTACCEPTING";
+    case MF_E_ATTRIBUTENOTFOUND:
+      return "NOTFOUND";
+    case MF_E_BUFFERTOOSMALL:
+      return "BUFFERTOOSMALL";
+    case E_NOTIMPL:
+      return "NOTIMPL";
+    default:
+      return "OTHER";
+  }
+}
+
+static const char* CodecStr(const GUID& aGUID) {
+  if (IsEqualGUID(aGUID, MFVideoFormat_H264)) {
+    return "H.264";
+  } else if (IsEqualGUID(aGUID, MFVideoFormat_VP80)) {
+    return "VP8";
+  } else if (IsEqualGUID(aGUID, MFVideoFormat_VP90)) {
+    return "VP9";
+  } else {
+    return "Unsupported codec";
+  }
+}
+
+static UINT32 EnumEncoders(const GUID& aSubtype, IMFActivate**& aActivates,
+                           const bool aUseHW = true) {
+  UINT32 num = 0;
+  MFT_REGISTER_TYPE_INFO inType = {.guidMajorType = MFMediaType_Video,
+                                   .guidSubtype = MFVideoFormat_NV12};
+  MFT_REGISTER_TYPE_INFO outType = {.guidMajorType = MFMediaType_Video,
+                                    .guidSubtype = aSubtype};
+  HRESULT hr = S_OK;
+  if (aUseHW) {
+    if (IsWin32kLockedDown()) {
+      // Some HW encoders use DXGI API and crash when locked down.
+      // TODO: move HW encoding out of content process (bug 1754531).
+      MFT_ENC_SLOGD("Don't use HW encoder when win32k locked down.");
+      return 0;
+    }
+
+    hr = wmf::MFTEnumEx(MFT_CATEGORY_VIDEO_ENCODER,
+                        MFT_ENUM_FLAG_HARDWARE | MFT_ENUM_FLAG_SORTANDFILTER,
+                        &inType, &outType, &aActivates, &num);
+    if (FAILED(hr)) {
+      MFT_ENC_SLOGE("enumerate HW encoder for %s: error=%s", CodecStr(aSubtype),
+                    ErrorStr(hr));
+      return 0;
+    }
+    if (num > 0) {
+      return num;
+    }
+  }
+
+  // Try software MFTs.
+  hr = wmf::MFTEnumEx(MFT_CATEGORY_VIDEO_ENCODER,
+                      MFT_ENUM_FLAG_SYNCMFT | MFT_ENUM_FLAG_ASYNCMFT |
+                          MFT_ENUM_FLAG_SORTANDFILTER,
+                      &inType, &outType, &aActivates, &num);
+  if (FAILED(hr)) {
+    MFT_ENC_SLOGE("enumerate SW encoder for %s: error=%s", CodecStr(aSubtype),
+                  ErrorStr(hr));
+    return 0;
+  }
+  if (num == 0) {
+    MFT_ENC_SLOGD("cannot find encoder for %s", CodecStr(aSubtype));
+  }
+  return num;
+}
+
+static HRESULT GetFriendlyName(IMFActivate* aAttributes, nsCString& aName) {
+  UINT32 len = 0;
+  HRESULT hr = aAttributes->GetStringLength(MFT_FRIENDLY_NAME_Attribute, &len);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+  if (len > 0) {
+    ++len;  // '\0'.
+    WCHAR name[len];
+    if (SUCCEEDED(aAttributes->GetString(MFT_FRIENDLY_NAME_Attribute, name, len,
+                                         nullptr))) {
+      aName.Append(NS_ConvertUTF16toUTF8(name));
+    }
+  }
+
+  if (aName.Length() == 0) {
+    aName.Append("Unknown MFT");
+  }
+
+  return S_OK;
+}
+
+static void PopulateEncoderInfo(const GUID& aSubtype,
+                                nsTArray<MFTEncoder::Info>& aInfos) {
+  IMFActivate** activates = nullptr;
+  UINT32 num = EnumEncoders(aSubtype, activates);
+  for (UINT32 i = 0; i < num; ++i) {
+    MFTEncoder::Info info = {.mSubtype = aSubtype};
+    GetFriendlyName(activates[i], info.mName);
+    aInfos.AppendElement(info);
+    MFT_ENC_SLOGD("<ENC> [%s] %s\n", CodecStr(aSubtype), info.mName.Data());
+    activates[i]->Release();
+    activates[i] = nullptr;
+  }
+  CoTaskMemFree(activates);
+}
+
+Maybe<MFTEncoder::Info> MFTEncoder::GetInfo(const GUID& aSubtype) {
+  nsTArray<Info>& infos = Infos();
+
+  for (auto i : infos) {
+    if (IsEqualGUID(aSubtype, i.mSubtype)) {
+      return Some(i);
+    }
+  }
+  return Nothing();
+}
+
+nsCString MFTEncoder::GetFriendlyName(const GUID& aSubtype) {
+  Maybe<Info> info = GetInfo(aSubtype);
+
+  return info ? info.ref().mName : "???"_ns;
+}
+
+// Called only once by Infos().
+nsTArray<MFTEncoder::Info> MFTEncoder::Enumerate() {
+  nsTArray<Info> infos;
+
+  if (!wmf::MediaFoundationInitializer::HasInitialized()) {
+    MFT_ENC_SLOGE("cannot init Media Foundation");
+    return infos;
+  }
+
+  PopulateEncoderInfo(MFVideoFormat_H264, infos);
+  PopulateEncoderInfo(MFVideoFormat_VP90, infos);
+  PopulateEncoderInfo(MFVideoFormat_VP80, infos);
+
+  return infos;
+}
+
+nsTArray<MFTEncoder::Info>& MFTEncoder::Infos() {
+  static nsTArray<Info> infos = Enumerate();
+  return infos;
+}
+
+already_AddRefed<IMFActivate> MFTEncoder::CreateFactory(const GUID& aSubtype) {
+  IMFActivate** activates = nullptr;
+  UINT32 num = EnumEncoders(aSubtype, activates, !mHardwareNotAllowed);
+  if (num == 0) {
+    return nullptr;
+  }
+
+  // Keep the first and throw out others, if there is any.
+  RefPtr<IMFActivate> factory = activates[0];
+  activates[0] = nullptr;
+  for (UINT32 i = 1; i < num; ++i) {
+    activates[i]->Release();
+    activates[i] = nullptr;
+  }
+  CoTaskMemFree(activates);
+
+  return factory.forget();
+}
+
+HRESULT MFTEncoder::Create(const GUID& aSubtype) {
+  MOZ_ASSERT(mscom::IsCurrentThreadMTA());
+  MOZ_ASSERT(!mEncoder);
+
+  RefPtr<IMFActivate> factory = CreateFactory(aSubtype);
+  if (!factory) {
+    return E_FAIL;
+  }
+
+  // Create MFT via the activation object.
+  RefPtr<IMFTransform> encoder;
+  HRESULT hr = factory->ActivateObject(
+      IID_PPV_ARGS(static_cast<IMFTransform**>(getter_AddRefs(encoder))));
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  RefPtr<ICodecAPI> config;
+  // Avoid IID_PPV_ARGS() here for MingGW fails to declare UUID for ICodecAPI.
+  hr = encoder->QueryInterface(IID_ICodecAPI, getter_AddRefs(config));
+  if (FAILED(hr)) {
+    encoder = nullptr;
+    factory->ShutdownObject();
+    return hr;
+  }
+
+  mFactory = std::move(factory);
+  mEncoder = std::move(encoder);
+  mConfig = std::move(config);
+  return S_OK;
+}
+
+HRESULT
+MFTEncoder::Destroy() {
+  if (!mEncoder) {
+    return S_OK;
+  }
+
+  mEncoder = nullptr;
+  mConfig = nullptr;
+  // Release MFT resources via activation object.
+  HRESULT hr = mFactory->ShutdownObject();
+  mFactory = nullptr;
+
+  return hr;
+}
+
+HRESULT
+MFTEncoder::SetMediaTypes(IMFMediaType* aInputType, IMFMediaType* aOutputType) {
+  MOZ_ASSERT(mscom::IsCurrentThreadMTA());
+  MOZ_ASSERT(aInputType && aOutputType);
+
+  AsyncMFTResult asyncMFT = AttemptEnableAsync();
+  NS_ENSURE_TRUE(asyncMFT.isOk(), asyncMFT.unwrapErr());
+
+  HRESULT hr = GetStreamIDs();
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  // Always set encoder output type before input.
+  hr = mEncoder->SetOutputType(mOutputStreamID, aOutputType, 0);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  NS_ENSURE_TRUE(MatchInputSubtype(aInputType) != GUID_NULL,
+                 MF_E_INVALIDMEDIATYPE);
+
+  hr = mEncoder->SetInputType(mInputStreamID, aInputType, 0);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  hr = mEncoder->GetInputStreamInfo(mInputStreamID, &mInputStreamInfo);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  hr = mEncoder->GetOutputStreamInfo(mInputStreamID, &mOutputStreamInfo);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+  mOutputStreamProvidesSample =
+      IsFlagSet(mOutputStreamInfo.dwFlags, MFT_OUTPUT_STREAM_PROVIDES_SAMPLES);
+
+  hr = SendMFTMessage(MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, 0);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  hr = SendMFTMessage(MFT_MESSAGE_NOTIFY_START_OF_STREAM, 0);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  if (asyncMFT.unwrap()) {
+    RefPtr<IMFMediaEventGenerator> source;
+    hr = mEncoder->QueryInterface(IID_PPV_ARGS(
+        static_cast<IMFMediaEventGenerator**>(getter_AddRefs(source))));
+    NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+    mEventSource.SetAsyncEventGenerator(source.forget());
+  } else {
+    mEventSource.InitSyncMFTEventQueue();
+  }
+
+  mNumNeedInput = 0;
+  return S_OK;
+}
+
+// Async MFT won't work without unlocking. See
+// https://docs.microsoft.com/en-us/windows/win32/medfound/asynchronous-mfts#unlocking-asynchronous-mfts
+MFTEncoder::AsyncMFTResult MFTEncoder::AttemptEnableAsync() {
+  IMFAttributes* pAttributes = nullptr;
+  HRESULT hr = mEncoder->GetAttributes(&pAttributes);
+  if (FAILED(hr)) {
+    return AsyncMFTResult(hr);
+  }
+
+  bool async =
+      MFGetAttributeUINT32(pAttributes, MF_TRANSFORM_ASYNC, FALSE) == TRUE;
+  if (async) {
+    hr = pAttributes->SetUINT32(MF_TRANSFORM_ASYNC_UNLOCK, TRUE);
+  } else {
+    hr = S_OK;
+  }
+  pAttributes->Release();
+
+  return SUCCEEDED(hr) ? AsyncMFTResult(async) : AsyncMFTResult(hr);
+}
+
+HRESULT MFTEncoder::GetStreamIDs() {
+  DWORD numIns;
+  DWORD numOuts;
+  HRESULT hr = mEncoder->GetStreamCount(&numIns, &numOuts);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+  if (numIns < 1 || numOuts < 1) {
+    MFT_ENC_LOGE("stream count error");
+    return MF_E_INVALIDSTREAMNUMBER;
+  }
+
+  DWORD inIDs[numIns];
+  DWORD outIDs[numOuts];
+  hr = mEncoder->GetStreamIDs(numIns, inIDs, numOuts, outIDs);
+  if (SUCCEEDED(hr)) {
+    mInputStreamID = inIDs[0];
+    mOutputStreamID = outIDs[0];
+  } else if (hr == E_NOTIMPL) {
+    mInputStreamID = 0;
+    mOutputStreamID = 0;
+  } else {
+    MFT_ENC_LOGE("failed to get stream IDs");
+    return hr;
+  }
+  return S_OK;
+}
+
+GUID MFTEncoder::MatchInputSubtype(IMFMediaType* aInputType) {
+  MOZ_ASSERT(mEncoder);
+  MOZ_ASSERT(aInputType);
+
+  GUID desired = GUID_NULL;
+  HRESULT hr = aInputType->GetGUID(MF_MT_SUBTYPE, &desired);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), GUID_NULL);
+  MOZ_ASSERT(desired != GUID_NULL);
+
+  DWORD i = 0;
+  IMFMediaType* inputType = nullptr;
+  GUID preferred = GUID_NULL;
+  while (true) {
+    hr = mEncoder->GetInputAvailableType(mInputStreamID, i, &inputType);
+    if (hr == MF_E_NO_MORE_TYPES) {
+      break;
+    }
+    NS_ENSURE_TRUE(SUCCEEDED(hr), GUID_NULL);
+
+    GUID sub = GUID_NULL;
+    hr = inputType->GetGUID(MF_MT_SUBTYPE, &sub);
+    NS_ENSURE_TRUE(SUCCEEDED(hr), GUID_NULL);
+
+    if (IsEqualGUID(desired, sub)) {
+      preferred = desired;
+      break;
+    }
+    ++i;
+  }
+
+  return IsEqualGUID(preferred, desired) ? preferred : GUID_NULL;
+}
+
+HRESULT
+MFTEncoder::SendMFTMessage(MFT_MESSAGE_TYPE aMsg, ULONG_PTR aData) {
+  MOZ_ASSERT(mscom::IsCurrentThreadMTA());
+  MOZ_ASSERT(mEncoder);
+
+  return mEncoder->ProcessMessage(aMsg, aData);
+}
+
+HRESULT MFTEncoder::SetModes(UINT32 aBitsPerSec) {
+  MOZ_ASSERT(mscom::IsCurrentThreadMTA());
+  MOZ_ASSERT(mConfig);
+
+  VARIANT var;
+  var.vt = VT_UI4;
+  var.ulVal = eAVEncCommonRateControlMode_CBR;
+  HRESULT hr = mConfig->SetValue(&CODECAPI_AVEncCommonRateControlMode, &var);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  var.ulVal = aBitsPerSec;
+  hr = mConfig->SetValue(&CODECAPI_AVEncCommonMeanBitRate, &var);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  if (SUCCEEDED(mConfig->IsModifiable(&CODECAPI_AVEncAdaptiveMode))) {
+    var.ulVal = eAVEncAdaptiveMode_Resolution;
+    hr = mConfig->SetValue(&CODECAPI_AVEncAdaptiveMode, &var);
+    NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+  }
+
+  if (SUCCEEDED(mConfig->IsModifiable(&CODECAPI_AVLowLatencyMode))) {
+    var.vt = VT_BOOL;
+    var.boolVal = VARIANT_TRUE;
+    hr = mConfig->SetValue(&CODECAPI_AVLowLatencyMode, &var);
+    NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+  }
+
+  return S_OK;
+}
+
+HRESULT
+MFTEncoder::SetBitrate(UINT32 aBitsPerSec) {
+  MOZ_ASSERT(mscom::IsCurrentThreadMTA());
+  MOZ_ASSERT(mConfig);
+
+  VARIANT var = {.vt = VT_UI4, .ulVal = aBitsPerSec};
+  return mConfig->SetValue(&CODECAPI_AVEncCommonMeanBitRate, &var);
+}
+
+static HRESULT CreateSample(RefPtr<IMFSample>* aOutSample, DWORD aSize,
+                            DWORD aAlignment) {
+  MOZ_ASSERT(mscom::IsCurrentThreadMTA());
+
+  HRESULT hr;
+  RefPtr<IMFSample> sample;
+  hr = wmf::MFCreateSample(getter_AddRefs(sample));
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  RefPtr<IMFMediaBuffer> buffer;
+  hr = wmf::MFCreateAlignedMemoryBuffer(aSize, aAlignment,
+                                        getter_AddRefs(buffer));
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  hr = sample->AddBuffer(buffer);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  *aOutSample = sample.forget();
+
+  return S_OK;
+}
+
+HRESULT
+MFTEncoder::CreateInputSample(RefPtr<IMFSample>* aSample, size_t aSize) {
+  MOZ_ASSERT(mscom::IsCurrentThreadMTA());
+
+  return CreateSample(
+      aSample, aSize,
+      mInputStreamInfo.cbAlignment > 0 ? mInputStreamInfo.cbAlignment - 1 : 0);
+}
+
+HRESULT
+MFTEncoder::PushInput(RefPtr<IMFSample>&& aInput) {
+  MOZ_ASSERT(mscom::IsCurrentThreadMTA());
+  MOZ_ASSERT(mEncoder);
+  MOZ_ASSERT(aInput);
+
+  mPendingInputs.Push(aInput.forget());
+  if (mEventSource.IsSync() && mNumNeedInput == 0) {
+    // To step 2 in
+    // https://docs.microsoft.com/en-us/windows/win32/medfound/basic-mft-processing-model#process-data
+    mNumNeedInput++;
+  }
+
+  HRESULT hr = ProcessInput();
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  return ProcessEvents();
+}
+
+HRESULT MFTEncoder::ProcessInput() {
+  MOZ_ASSERT(mscom::IsCurrentThreadMTA());
+  MOZ_ASSERT(mEncoder);
+
+  if (mNumNeedInput == 0 || mPendingInputs.GetSize() == 0) {
+    return S_OK;
+  }
+
+  RefPtr<IMFSample> input = mPendingInputs.PopFront();
+  HRESULT hr = mEncoder->ProcessInput(mInputStreamID, input, 0);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+  --mNumNeedInput;
+
+  if (!mEventSource.IsSync()) {
+    return S_OK;
+  }
+  // For sync MFT: Step 3 in
+  // https://docs.microsoft.com/en-us/windows/win32/medfound/basic-mft-processing-model#process-data
+  DWORD flags = 0;
+  hr = mEncoder->GetOutputStatus(&flags);
+  MediaEventType evType = MEUnknown;
+  switch (hr) {
+    case S_OK:
+      evType = flags == MFT_OUTPUT_STATUS_SAMPLE_READY
+                   ? METransformHaveOutput  // To step 4: ProcessOutput().
+                   : METransformNeedInput;  // To step 2: ProcessInput().
+      break;
+    case E_NOTIMPL:
+      evType = METransformHaveOutput;  // To step 4: ProcessOutput().
+      break;
+    default:
+      MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE("undefined output status");
+      return hr;
+  }
+  return mEventSource.QueueSyncMFTEvent(evType);
+}
+
+HRESULT MFTEncoder::ProcessEvents() {
+  MOZ_ASSERT(mscom::IsCurrentThreadMTA());
+  MOZ_ASSERT(mEncoder);
+
+  HRESULT hr = E_FAIL;
+  while (true) {
+    Event event = mEventSource.GetEvent();
+    if (event.isErr()) {
+      hr = event.unwrapErr();
+      break;
+    }
+
+    MediaEventType evType = event.unwrap();
+    switch (evType) {
+      case METransformNeedInput:
+        ++mNumNeedInput;
+        hr = ProcessInput();
+        NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+        break;
+      case METransformHaveOutput:
+        hr = ProcessOutput();
+        NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+        break;
+      case METransformDrainComplete:
+        mDrainState = DrainState::DRAINED;
+        break;
+      default:
+        MFT_ENC_LOGE("unsupported event: %lx", evType);
+    }
+  }
+
+  switch (hr) {
+    case MF_E_NO_EVENTS_AVAILABLE:
+      return S_OK;
+    case MF_E_MULTIPLE_SUBSCRIBERS:
+    default:
+      MFT_ENC_LOGE("failed to get event: %s", ErrorStr(hr));
+      return hr;
+  }
+}
+
+HRESULT MFTEncoder::ProcessOutput() {
+  MOZ_ASSERT(mscom::IsCurrentThreadMTA());
+  MOZ_ASSERT(mEncoder);
+
+  MFT_OUTPUT_DATA_BUFFER output = {.dwStreamID = mOutputStreamID,
+                                   .pSample = nullptr,
+                                   .dwStatus = 0,
+                                   .pEvents = nullptr};
+  RefPtr<IMFSample> sample;
+  HRESULT hr = E_FAIL;
+  if (!mOutputStreamProvidesSample) {
+    hr = CreateSample(&sample, mOutputStreamInfo.cbSize,
+                      mOutputStreamInfo.cbAlignment > 1
+                          ? mOutputStreamInfo.cbAlignment - 1
+                          : 0);
+    NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+    output.pSample = sample;
+  }
+
+  DWORD status = 0;
+  hr = mEncoder->ProcessOutput(0, 1, &output, &status);
+  if (hr == MF_E_TRANSFORM_STREAM_CHANGE) {
+    MFT_ENC_LOGD("output stream change");
+    if (output.dwStatus & MFT_OUTPUT_DATA_BUFFER_FORMAT_CHANGE) {
+      // Follow the instructions in Microsoft doc:
+      // https://docs.microsoft.com/en-us/windows/win32/medfound/handling-stream-changes#output-type
+      IMFMediaType* outputType = nullptr;
+      hr = mEncoder->GetOutputAvailableType(mOutputStreamID, 0, &outputType);
+      NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+      hr = mEncoder->SetOutputType(mOutputStreamID, outputType, 0);
+      NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+    }
+    return MF_E_TRANSFORM_STREAM_CHANGE;
+  }
+
+  // Step 8 in
+  // https://docs.microsoft.com/en-us/windows/win32/medfound/basic-mft-processing-model#process-data
+  if (hr == MF_E_TRANSFORM_NEED_MORE_INPUT) {
+    MOZ_ASSERT(mEventSource.IsSync());
+    MOZ_ASSERT(mDrainState == DrainState::DRAINING);
+
+    mEventSource.QueueSyncMFTEvent(METransformDrainComplete);
+    return S_OK;
+  }
+
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  mOutputs.AppendElement(output.pSample);
+  if (mOutputStreamProvidesSample) {
+    // Release MFT provided sample.
+    output.pSample->Release();
+    output.pSample = nullptr;
+  }
+
+  return S_OK;
+}
+
+HRESULT MFTEncoder::TakeOutput(nsTArray<RefPtr<IMFSample>>& aOutput) {
+  MOZ_ASSERT(aOutput.Length() == 0);
+  aOutput.SwapElements(mOutputs);
+  return S_OK;
+}
+
+HRESULT MFTEncoder::Drain(nsTArray<RefPtr<IMFSample>>& aOutput) {
+  MOZ_ASSERT(mscom::IsCurrentThreadMTA());
+  MOZ_ASSERT(mEncoder);
+  MOZ_ASSERT(aOutput.Length() == 0);
+
+  switch (mDrainState) {
+    case DrainState::DRAINABLE:
+      // Exhaust pending inputs.
+      while (mPendingInputs.GetSize() > 0) {
+        if (mEventSource.IsSync()) {
+          // Step 5 in
+          // https://docs.microsoft.com/en-us/windows/win32/medfound/basic-mft-processing-model#process-data
+          mEventSource.QueueSyncMFTEvent(METransformNeedInput);
+        }
+        HRESULT hr = ProcessEvents();
+        NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+      }
+      SendMFTMessage(MFT_MESSAGE_COMMAND_DRAIN, 0);
+      mDrainState = DrainState::DRAINING;
+      [[fallthrough]];  // To collect and return outputs.
+    case DrainState::DRAINING:
+      // Collect remaining outputs.
+      while (mOutputs.Length() == 0 && mDrainState != DrainState::DRAINED) {
+        if (mEventSource.IsSync()) {
+          // Step 8 in
+          // https://docs.microsoft.com/en-us/windows/win32/medfound/basic-mft-processing-model#process-data
+          mEventSource.QueueSyncMFTEvent(METransformHaveOutput);
+        }
+        HRESULT hr = ProcessEvents();
+        NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+      }
+      [[fallthrough]];  // To return outputs.
+    case DrainState::DRAINED:
+      aOutput.SwapElements(mOutputs);
+      return S_OK;
+  }
+}
+
+HRESULT MFTEncoder::GetMPEGSequenceHeader(nsTArray<UINT8>& aHeader) {
+  MOZ_ASSERT(mscom::IsCurrentThreadMTA());
+  MOZ_ASSERT(mEncoder);
+  MOZ_ASSERT(aHeader.Length() == 0);
+
+  RefPtr<IMFMediaType> outputType;
+  HRESULT hr = mEncoder->GetOutputCurrentType(mOutputStreamID,
+                                              getter_AddRefs(outputType));
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  UINT32 length = 0;
+  hr = outputType->GetBlobSize(MF_MT_MPEG_SEQUENCE_HEADER, &length);
+  if (hr == MF_E_ATTRIBUTENOTFOUND || length == 0) {
+    return S_OK;
+  }
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  aHeader.SetCapacity(length);
+  hr = outputType->GetBlob(MF_MT_MPEG_SEQUENCE_HEADER, aHeader.Elements(),
+                           length, nullptr);
+  aHeader.SetLength(SUCCEEDED(hr) ? length : 0);
+
+  return hr;
+}
+
+MFTEncoder::Event MFTEncoder::EventSource::GetEvent() {
+  if (IsSync()) {
+    return GetSyncMFTEvent();
+  }
+
+  RefPtr<IMFMediaEvent> event;
+  HRESULT hr = mImpl.as<RefPtr<IMFMediaEventGenerator>>()->GetEvent(
+      MF_EVENT_FLAG_NO_WAIT, getter_AddRefs(event));
+  MediaEventType type = MEUnknown;
+  if (SUCCEEDED(hr)) {
+    hr = event->GetType(&type);
+  }
+  return SUCCEEDED(hr) ? Event{type} : Event{hr};
+}
+
+HRESULT MFTEncoder::EventSource::QueueSyncMFTEvent(MediaEventType aEventType) {
+  MOZ_ASSERT(IsSync());
+  MOZ_ASSERT(IsOnCurrentThread());
+
+  auto q = mImpl.as<UniquePtr<EventQueue>>().get();
+  q->push(aEventType);
+  return S_OK;
+}
+
+MFTEncoder::Event MFTEncoder::EventSource::GetSyncMFTEvent() {
+  MOZ_ASSERT(IsOnCurrentThread());
+
+  auto q = mImpl.as<UniquePtr<EventQueue>>().get();
+  if (q->empty()) {
+    return Event{MF_E_NO_EVENTS_AVAILABLE};
+  }
+
+  MediaEventType type = q->front();
+  q->pop();
+  return Event{type};
+}
+
+#ifdef DEBUG
+bool MFTEncoder::EventSource::IsOnCurrentThread() {
+  if (!mThread) {
+    mThread = GetCurrentSerialEventTarget();
+  }
+  return mThread->IsOnCurrentThread();
+}
+#endif
+
+}  // namespace mozilla
+
+#undef MFT_ENC_SLOGE
+#undef MFT_ENC_SLOGD
+#undef MFT_ENC_LOGE
+#undef MFT_ENC_LOGD