horok/firefox
1
0
Fork 0
Code Activity
firefox/dom/media/platforms/wmf/MFTEncoder.cpp
Daniel Baumann 5e9a113729
Adding upstream version 140.0. 
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
2025-06-25 09:37:52 +02:00

821 lines
24 KiB
C++
Raw Permalink Blame History

/* -*- 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/COMWrappers.h"
#include "mozilla/mscom/Utils.h"
#include "WMFUtils.h"
#include <comdef.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;
}
mscom::wrapped::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;
}
mscom::wrapped::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) {
MFT_ENC_LOGE("CreateFactory error");
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))));
if (FAILED(hr)) {
_com_error error(hr);
MFT_ENC_LOGE("MFTEncoder::Create: error = 0x%lX, %ls", hr,
error.ErrorMessage());
return 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)) {
MFT_ENC_LOGE("QueryInterface IID_ICodecAPI error");
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();
if (asyncMFT.isErr()) {
HRESULT hr = asyncMFT.inspectErr();
_com_error error(hr);
MFT_ENC_LOGE("AttemptEnableAsync error: %ls", error.ErrorMessage());
return asyncMFT.inspectErr();
}
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)) {
MFT_ENC_LOGE("Encoder->GetAttribute error");
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();
if (FAILED(hr)) {
MFT_ENC_LOGE("Setting async unlock");
}
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(const EncoderConfig& aConfig) {
MOZ_ASSERT(mscom::IsCurrentThreadMTA());
MOZ_ASSERT(mConfig);
VARIANT var;
var.vt = VT_UI4;
switch (aConfig.mBitrateMode) {
case BitrateMode::Constant:
var.ulVal = eAVEncCommonRateControlMode_CBR;
break;
case BitrateMode::Variable:
if (aConfig.mCodec == CodecType::VP8 ||
aConfig.mCodec == CodecType::VP9) {
MFT_ENC_LOGE(
"Overriding requested VRB bitrate mode, forcing CBR for VP8/VP9 "
"encoding.");
var.ulVal = eAVEncCommonRateControlMode_CBR;
} else {
var.ulVal = eAVEncCommonRateControlMode_PeakConstrainedVBR;
}
break;
}
HRESULT hr = mConfig->SetValue(&CODECAPI_AVEncCommonRateControlMode, &var);
NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
if (aConfig.mBitrate) {
var.ulVal = aConfig.mBitrate;
hr = mConfig->SetValue(&CODECAPI_AVEncCommonMeanBitRate, &var);
if (FAILED(hr)) {
MFT_ENC_LOGE("Couln't set bitrate to %d", aConfig.mBitrate);
return hr;
}
}
switch (aConfig.mScalabilityMode) {
case ScalabilityMode::None:
var.ulVal = 1;
break;
case ScalabilityMode::L1T2:
var.ulVal = 2;
break;
case ScalabilityMode::L1T3:
var.ulVal = 3;
break;
}
bool isIntel = false; // TODO check this
if (aConfig.mScalabilityMode != ScalabilityMode::None || isIntel) {
hr = mConfig->SetValue(&CODECAPI_AVEncVideoTemporalLayerCount, &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 =
aConfig.mUsage == Usage::Realtime ? VARIANT_TRUE : VARIANT_FALSE;
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(const InputSample& aInput) {
MOZ_ASSERT(mscom::IsCurrentThreadMTA());
MOZ_ASSERT(mEncoder);
mPendingInputs.push_back(aInput);
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.empty()) {
return S_OK;
}
auto input = mPendingInputs.front();
mPendingInputs.pop_front();
HRESULT hr = mEncoder->ProcessInput(mInputStreamID, input.mSample, 0);
if (input.mKeyFrameRequested) {
VARIANT v = {.vt = VT_UI4, .ulVal = 1};
mConfig->SetValue(&CODECAPI_AVEncVideoForceKeyFrame, &v);
}
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:
MFT_ENC_LOGD("State is now DrainState::DRAINED");
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.empty()) {
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);
MFT_ENC_LOGD("State is now DrainState::DRAINING");
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);
mDrainState = DrainState::DRAINABLE;
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
View git blame Copy permalink