dom/media/ipc/MFMediaEngineUtils.h

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #ifndef DOM_MEDIA_IPC_MFMEDIAENGINEUTILS_H_
   6 #define DOM_MEDIA_IPC_MFMEDIAENGINEUTILS_H_
   7
   8 #include "MFMediaEngineExtra.h"
   9 #include "ipc/EnumSerializer.h"
  10 #include "mozilla/Logging.h"
  11 #include "mozilla/ProfilerMarkerTypes.h"
  12 #include "nsPrintfCString.h"
  13
  14 namespace mozilla {
  15
  16 inline LazyLogModule gMFMediaEngineLog{"MFMediaEngine"};
  17
  18 // https://docs.microsoft.com/en-us/windows/win32/api/mfmediaengine/ne-mfmediaengine-mf_media_engine_event
  19 using MFMediaEngineEvent = MF_MEDIA_ENGINE_EVENT;
  20
  21 // https://docs.microsoft.com/en-us/windows/win32/api/mfmediaengine/ne-mfmediaengine-mf_media_engine_err
  22 using MFMediaEngineError = MF_MEDIA_ENGINE_ERR;
  23
  24 #define LOG_AND_WARNING(msg, ...)                                \
  25   do {                                                           \
  26     NS_WARNING(nsPrintfCString(msg, rv).get());                  \
  27     MOZ_LOG(gMFMediaEngineLog, LogLevel::Debug,                  \
  28             ("%s:%d, " msg, __FILE__, __LINE__, ##__VA_ARGS__)); \
  29   } while (false)
  30
  31 #ifndef LOG_IF_FAILED
  32 #  define LOG_IF_FAILED(x)                              \
  33     do {                                                \
  34       HRESULT rv = x;                                   \
  35       if (MOZ_UNLIKELY(FAILED(rv))) {                   \
  36         LOG_AND_WARNING("(" #x ") failed, rv=%lx", rv); \
  37       }                                                 \
  38     } while (false)
  39 #endif
  40
  41 #ifndef RETURN_IF_FAILED
  42 #  define RETURN_IF_FAILED(x)                           \
  43     do {                                                \
  44       HRESULT rv = x;                                   \
  45       if (MOZ_UNLIKELY(FAILED(rv))) {                   \
  46         LOG_AND_WARNING("(" #x ") failed, rv=%lx", rv); \
  47         return rv;                                      \
  48       }                                                 \
  49     } while (false)
  50 #endif
  51
  52 #ifndef RETURN_VOID_IF_FAILED
  53 #  define RETURN_VOID_IF_FAILED(x)                      \
  54     do {                                                \
  55       HRESULT rv = x;                                   \
  56       if (MOZ_UNLIKELY(FAILED(rv))) {                   \
  57         LOG_AND_WARNING("(" #x ") failed, rv=%lx", rv); \
  58         return;                                         \
  59       }                                                 \
  60     } while (false)
  61 #endif
  62
  63 #ifndef RETURN_PARAM_IF_FAILED
  64 #  define RETURN_PARAM_IF_FAILED(x, defaultOut)         \
  65     do {                                                \
  66       HRESULT rv = x;                                   \
  67       if (MOZ_UNLIKELY(FAILED(rv))) {                   \
  68         LOG_AND_WARNING("(" #x ") failed, rv=%lx", rv); \
  69         return defaultOut;                              \
  70       }                                                 \
  71     } while (false)
  72 #endif
  73
  74 #ifndef SHUTDOWN_IF_POSSIBLE
  75 #  define SHUTDOWN_IF_POSSIBLE(class)                                        \
  76     do {                                                                     \
  77       IMFShutdown* pShutdown = nullptr;                                      \
  78       HRESULT rv = class->QueryInterface(IID_PPV_ARGS(&pShutdown));          \
  79       if (SUCCEEDED(rv)) {                                                   \
  80         rv = pShutdown->Shutdown();                                          \
  81         if (FAILED(rv)) {                                                    \
  82           LOG_AND_WARNING(#class " failed to shutdown, rv=%lx", rv);         \
  83         } else {                                                             \
  84           MOZ_LOG(gMFMediaEngineLog, LogLevel::Verbose,                      \
  85                   ((#class " shutdowned successfully")));                    \
  86         }                                                                    \
  87         pShutdown->Release();                                                \
  88       } else {                                                               \
  89         LOG_AND_WARNING(#class " doesn't support IMFShutdown?, rv=%lx", rv); \
  90       }                                                                      \
  91     } while (false)
  92 #endif
  93
  94 #define ENGINE_MARKER(markerName) \
  95   PROFILER_MARKER(markerName, MEDIA_PLAYBACK, {}, MediaEngineMarker, Id())
  96
  97 #define ENGINE_MARKER_TEXT(markerName, text)                                   \
  98   PROFILER_MARKER(markerName, MEDIA_PLAYBACK, {}, MediaEngineTextMarker, Id(), \
  99                   text)
 100
 101 const char* MediaEventTypeToStr(MediaEventType aType);
 102 const char* MediaEngineEventToStr(MF_MEDIA_ENGINE_EVENT aEvent);
 103 const char* MFMediaEngineErrorToStr(MFMediaEngineError aError);
 104 const char* GUIDToStr(GUID aGUID);
 105 const char* MFVideoRotationFormatToStr(MFVideoRotationFormat aFormat);
 106 const char* MFVideoTransferFunctionToStr(MFVideoTransferFunction aFunc);
 107 const char* MFVideoPrimariesToStr(MFVideoPrimaries aPrimaries);
 108 void ByteArrayFromGUID(REFGUID aGuidIn, nsTArray<uint8_t>& aByteArrayOut);
 109 void GUIDFromByteArray(const nsTArray<uint8_t>& aByteArrayIn, GUID& aGuidOut);
 110 BSTR CreateBSTRFromConstChar(const char* aNarrowStr);
 111
 112 // See cdm::SubsampleEntry
 113 struct MediaFoundationSubsampleEntry {
 114   uint32_t mClearBytes;
 115   uint32_t mCipherBytes;
 116 };
 117
 118 template <typename T>
 119 class ScopedCoMem {
 120  public:
 121   ScopedCoMem() : mPtr(nullptr) {}
 122
 123   ~ScopedCoMem() { Reset(nullptr); }
 124
 125   ScopedCoMem(const ScopedCoMem&) = delete;
 126   ScopedCoMem& operator=(const ScopedCoMem&) = delete;
 127
 128   T** operator&() {               // NOLINT
 129     MOZ_ASSERT(mPtr == nullptr);  // To catch memory leaks.
 130     return &mPtr;
 131   }
 132
 133   operator T*() { return mPtr; }
 134
 135   T* operator->() {
 136     MOZ_ASSERT(mPtr != nullptr);
 137     return mPtr;
 138   }
 139
 140   const T* operator->() const {
 141     MOZ_ASSERT(mPtr != nullptr);
 142     return mPtr;
 143   }
 144
 145   explicit operator bool() const { return mPtr; }
 146
 147   friend bool operator==(const ScopedCoMem& lhs, std::nullptr_t) {
 148     return lhs.Get() == nullptr;
 149   }
 150
 151   friend bool operator==(std::nullptr_t, const ScopedCoMem& rhs) {
 152     return rhs.Get() == nullptr;
 153   }
 154
 155   friend bool operator!=(const ScopedCoMem& lhs, std::nullptr_t) {
 156     return lhs.Get() != nullptr;
 157   }
 158
 159   friend bool operator!=(std::nullptr_t, const ScopedCoMem& rhs) {
 160     return rhs.Get() != nullptr;
 161   }
 162
 163   void Reset(T* ptr) {
 164     if (mPtr) CoTaskMemFree(mPtr);
 165     mPtr = ptr;
 166   }
 167
 168   T* Get() const { return mPtr; }
 169
 170  private:
 171   T* mPtr;
 172 };
 173
 174 }  // namespace mozilla
 175
 176 namespace IPC {
 177
 178 template <>
 179 struct ParamTraits<mozilla::MFMediaEngineError>
 180     : public ContiguousEnumSerializerInclusive<
 181           mozilla::MFMediaEngineError,
 182           mozilla::MFMediaEngineError::MF_MEDIA_ENGINE_ERR_ABORTED,
 183           mozilla::MFMediaEngineError::MF_MEDIA_ENGINE_ERR_ENCRYPTED> {};
 184
 185 template <>
 186 struct ParamTraits<mozilla::MFMediaEngineEvent>
 187     : public ContiguousEnumSerializerInclusive<
 188           mozilla::MFMediaEngineEvent,
 189           mozilla::MFMediaEngineEvent::MF_MEDIA_ENGINE_EVENT_LOADSTART,
 190           mozilla::MFMediaEngineEvent::
 191               MF_MEDIA_ENGINE_EVENT_AUDIOENDPOINTCHANGE> {};
 192
 193 }  // namespace IPC
 194
 195 #endif  // DOM_MEDIA_IPC_MFMEDIAENGINECHILD_H_