Source code
Revision control
Copy as Markdown
Other Tools
/* 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
#ifndef DOM_MEDIA_IPC_MFMEDIAENGINEUTILS_H_
#define DOM_MEDIA_IPC_MFMEDIAENGINEUTILS_H_
#include "MFMediaEngineExtra.h"
#include "ipc/EnumSerializer.h"
#include "mozilla/Logging.h"
#include "mozilla/ProfilerMarkerTypes.h"
#include "nsPrintfCString.h"
namespace mozilla {
inline LazyLogModule gMFMediaEngineLog{"MFMediaEngine"};
using MFMediaEngineEvent = MF_MEDIA_ENGINE_EVENT;
using MFMediaEngineError = MF_MEDIA_ENGINE_ERR;
#define LOG_AND_WARNING(msg, ...) \
do { \
NS_WARNING(nsPrintfCString(msg, rv).get()); \
MOZ_LOG(gMFMediaEngineLog, LogLevel::Debug, \
("%s:%d, " msg, __FILE__, __LINE__, ##__VA_ARGS__)); \
} while (false)
#ifndef LOG_IF_FAILED
# define LOG_IF_FAILED(x) \
do { \
HRESULT rv = x; \
if (MOZ_UNLIKELY(FAILED(rv))) { \
LOG_AND_WARNING("(" #x ") failed, rv=%lx", rv); \
} \
} while (false)
#endif
#ifndef RETURN_IF_FAILED
# define RETURN_IF_FAILED(x) \
do { \
HRESULT rv = x; \
if (MOZ_UNLIKELY(FAILED(rv))) { \
LOG_AND_WARNING("(" #x ") failed, rv=%lx", rv); \
return rv; \
} \
} while (false)
#endif
#ifndef RETURN_VOID_IF_FAILED
# define RETURN_VOID_IF_FAILED(x) \
do { \
HRESULT rv = x; \
if (MOZ_UNLIKELY(FAILED(rv))) { \
LOG_AND_WARNING("(" #x ") failed, rv=%lx", rv); \
return; \
} \
} while (false)
#endif
#ifndef RETURN_PARAM_IF_FAILED
# define RETURN_PARAM_IF_FAILED(x, defaultOut) \
do { \
HRESULT rv = x; \
if (MOZ_UNLIKELY(FAILED(rv))) { \
LOG_AND_WARNING("(" #x ") failed, rv=%lx", rv); \
return defaultOut; \
} \
} while (false)
#endif
#ifndef SHUTDOWN_IF_POSSIBLE
# define SHUTDOWN_IF_POSSIBLE(class) \
do { \
IMFShutdown* pShutdown = nullptr; \
HRESULT rv = class->QueryInterface(IID_PPV_ARGS(&pShutdown)); \
if (SUCCEEDED(rv)) { \
rv = pShutdown->Shutdown(); \
if (FAILED(rv)) { \
LOG_AND_WARNING(#class " failed to shutdown, rv=%lx", rv); \
} else { \
MOZ_LOG(gMFMediaEngineLog, LogLevel::Verbose, \
((#class " shutdowned successfully"))); \
} \
pShutdown->Release(); \
} else { \
LOG_AND_WARNING(#class " doesn't support IMFShutdown?, rv=%lx", rv); \
} \
} while (false)
#endif
#define ENGINE_MARKER(markerName) \
PROFILER_MARKER(markerName, MEDIA_PLAYBACK, {}, MediaEngineMarker, Id())
#define ENGINE_MARKER_TEXT(markerName, text) \
PROFILER_MARKER(markerName, MEDIA_PLAYBACK, {}, MediaEngineTextMarker, Id(), \
text)
const char* MediaEventTypeToStr(MediaEventType aType);
const char* MediaEngineEventToStr(MF_MEDIA_ENGINE_EVENT aEvent);
const char* MFMediaEngineErrorToStr(MFMediaEngineError aError);
const char* GUIDToStr(GUID aGUID);
const char* MFVideoRotationFormatToStr(MFVideoRotationFormat aFormat);
const char* MFVideoTransferFunctionToStr(MFVideoTransferFunction aFunc);
const char* MFVideoPrimariesToStr(MFVideoPrimaries aPrimaries);
void ByteArrayFromGUID(REFGUID aGuidIn, nsTArray<uint8_t>& aByteArrayOut);
void GUIDFromByteArray(const nsTArray<uint8_t>& aByteArrayIn, GUID& aGuidOut);
BSTR CreateBSTRFromConstChar(const char* aNarrowStr);
// See cdm::SubsampleEntry
struct MediaFoundationSubsampleEntry {
uint32_t mClearBytes;
uint32_t mCipherBytes;
};
template <typename T>
class ScopedCoMem {
public:
ScopedCoMem() : mPtr(nullptr) {}
~ScopedCoMem() { Reset(nullptr); }
ScopedCoMem(const ScopedCoMem&) = delete;
ScopedCoMem& operator=(const ScopedCoMem&) = delete;
T** operator&() { // NOLINT
MOZ_ASSERT(mPtr == nullptr); // To catch memory leaks.
return &mPtr;
}
operator T*() { return mPtr; }
T* operator->() {
MOZ_ASSERT(mPtr != nullptr);
return mPtr;
}
const T* operator->() const {
MOZ_ASSERT(mPtr != nullptr);
return mPtr;
}
explicit operator bool() const { return mPtr; }
friend bool operator==(const ScopedCoMem& lhs, std::nullptr_t) {
return lhs.Get() == nullptr;
}
friend bool operator==(std::nullptr_t, const ScopedCoMem& rhs) {
return rhs.Get() == nullptr;
}
friend bool operator!=(const ScopedCoMem& lhs, std::nullptr_t) {
return lhs.Get() != nullptr;
}
friend bool operator!=(std::nullptr_t, const ScopedCoMem& rhs) {
return rhs.Get() != nullptr;
}
void Reset(T* ptr) {
if (mPtr) CoTaskMemFree(mPtr);
mPtr = ptr;
}
T* Get() const { return mPtr; }
private:
T* mPtr;
};
} // namespace mozilla
namespace IPC {
template <>
struct ParamTraits<mozilla::MFMediaEngineError>
: public ContiguousEnumSerializerInclusive<
mozilla::MFMediaEngineError,
mozilla::MFMediaEngineError::MF_MEDIA_ENGINE_ERR_ABORTED,
mozilla::MFMediaEngineError::MF_MEDIA_ENGINE_ERR_ENCRYPTED> {};
template <>
struct ParamTraits<mozilla::MFMediaEngineEvent>
: public ContiguousEnumSerializerInclusive<
mozilla::MFMediaEngineEvent,
mozilla::MFMediaEngineEvent::MF_MEDIA_ENGINE_EVENT_LOADSTART,
mozilla::MFMediaEngineEvent::
MF_MEDIA_ENGINE_EVENT_AUDIOENDPOINTCHANGE> {};
} // namespace IPC
#endif // DOM_MEDIA_IPC_MFMEDIAENGINECHILD_H_