diff --git a/srcpkgs/firefox/patches/fix-build-tier3.patch b/srcpkgs/firefox/patches/fix-build-tier3.patch
new file mode 100644
index 00000000000..c7f5b7ea1f7
--- /dev/null
+++ b/srcpkgs/firefox/patches/fix-build-tier3.patch
@@ -0,0 +1,366 @@
+commit 8a0c895dee94b3c15e56557eb1dd0114477a6056
+Author: q66 <daniel@octaforge.org>
+Date:   Sun Apr 10 00:38:30 2022 +0200
+
+    fix build on tier 3 platforms
+    
+    https://bugzilla.mozilla.org/show_bug.cgi?id=1758610
+
+diff --git a/dom/media/platforms/ffmpeg/FFmpegVideoDecoder.cpp b/dom/media/platforms/ffmpeg/FFmpegVideoDecoder.cpp
+index 0fa127b..78c8961 100644
+--- a/dom/media/platforms/ffmpeg/FFmpegVideoDecoder.cpp
++++ b/dom/media/platforms/ffmpeg/FFmpegVideoDecoder.cpp
+@@ -814,7 +814,7 @@ MediaResult FFmpegVideoDecoder<LIBAV_VER>::DoDecode(
+ #  ifdef MOZ_WAYLAND_USE_VAAPI
+     // Create VideoFramePool in case we need it.
+     if (!mVideoFramePool && mEnableHardwareDecoding) {
+-      mVideoFramePool = MakeUnique<VideoFramePool>();
++      mVideoFramePool = MakeUnique<VideoFramePool<LIBAV_VER>>();
+     }
+ 
+     // Release unused VA-API surfaces before avcodec_receive_frame() as
+diff --git a/dom/media/platforms/ffmpeg/FFmpegVideoDecoder.h b/dom/media/platforms/ffmpeg/FFmpegVideoDecoder.h
+index b1a2f73..c77d76f 100644
+--- a/dom/media/platforms/ffmpeg/FFmpegVideoDecoder.h
++++ b/dom/media/platforms/ffmpeg/FFmpegVideoDecoder.h
+@@ -16,6 +16,9 @@
+ #if LIBAVCODEC_VERSION_MAJOR >= 57 && LIBAVUTIL_VERSION_MAJOR >= 56
+ #  include "mozilla/layers/TextureClient.h"
+ #endif
++#ifdef MOZ_WAYLAND_USE_VAAPI
++#  include "FFmpegVideoFramePool.h"
++#endif
+ 
+ struct _VADRMPRIMESurfaceDescriptor;
+ typedef struct _VADRMPRIMESurfaceDescriptor VADRMPRIMESurfaceDescriptor;
+@@ -23,7 +26,6 @@ typedef struct _VADRMPRIMESurfaceDescriptor VADRMPRIMESurfaceDescriptor;
+ namespace mozilla {
+ 
+ class ImageBufferWrapper;
+-class VideoFramePool;
+ 
+ template <int V>
+ class FFmpegVideoDecoder : public FFmpegDataDecoder<V> {};
+@@ -138,7 +140,7 @@ class FFmpegVideoDecoder<LIBAV_VER>
+   AVBufferRef* mVAAPIDeviceContext;
+   bool mEnableHardwareDecoding;
+   VADisplay mDisplay;
+-  UniquePtr<VideoFramePool> mVideoFramePool;
++  UniquePtr<VideoFramePool<LIBAV_VER>> mVideoFramePool;
+   static nsTArray<AVCodecID> mAcceleratedFormats;
+ #endif
+   RefPtr<KnowsCompositor> mImageAllocator;
+diff --git a/dom/media/platforms/ffmpeg/FFmpegVideoFramePool.cpp b/dom/media/platforms/ffmpeg/FFmpegVideoFramePool.cpp
+index 7943e09..673b3fc 100644
+--- a/dom/media/platforms/ffmpeg/FFmpegVideoFramePool.cpp
++++ b/dom/media/platforms/ffmpeg/FFmpegVideoFramePool.cpp
+@@ -5,6 +5,7 @@
+  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+ 
+ #include "FFmpegVideoFramePool.h"
++#include "PlatformDecoderModule.h"
+ #include "FFmpegLog.h"
+ #include "mozilla/widget/DMABufLibWrapper.h"
+ #include "libavutil/pixfmt.h"
+@@ -15,11 +16,11 @@
+ 
+ namespace mozilla {
+ 
+-RefPtr<layers::Image> VideoFrameSurfaceVAAPI::GetAsImage() {
++RefPtr<layers::Image> VideoFrameSurface<LIBAV_VER>::GetAsImage() {
+   return new layers::DMABUFSurfaceImage(mSurface);
+ }
+ 
+-VideoFrameSurfaceVAAPI::VideoFrameSurfaceVAAPI(DMABufSurface* aSurface)
++VideoFrameSurface<LIBAV_VER>::VideoFrameSurface(DMABufSurface* aSurface)
+     : mSurface(aSurface),
+       mLib(nullptr),
+       mAVHWFramesContext(nullptr),
+@@ -30,22 +31,22 @@ VideoFrameSurfaceVAAPI::VideoFrameSurfaceVAAPI(DMABufSurface* aSurface)
+   MOZ_ASSERT(mSurface);
+   MOZ_RELEASE_ASSERT(mSurface->GetAsDMABufSurfaceYUV());
+   mSurface->GlobalRefCountCreate();
+-  FFMPEG_LOG("VideoFrameSurfaceVAAPI: creating surface UID = %d",
++  FFMPEG_LOG("VideoFrameSurface: creating surface UID = %d",
+              mSurface->GetUID());
+ }
+ 
+-void VideoFrameSurfaceVAAPI::LockVAAPIData(AVCodecContext* aAVCodecContext,
+-                                           AVFrame* aAVFrame,
+-                                           FFmpegLibWrapper* aLib) {
+-  FFMPEG_LOG("VideoFrameSurfaceVAAPI: VAAPI locking dmabuf surface UID = %d",
++void VideoFrameSurface<LIBAV_VER>::LockVAAPIData(AVCodecContext* aAVCodecContext,
++                                                 AVFrame* aAVFrame,
++                                                 FFmpegLibWrapper* aLib) {
++  FFMPEG_LOG("VideoFrameSurface: VAAPI locking dmabuf surface UID = %d",
+              mSurface->GetUID());
+   mLib = aLib;
+   mAVHWFramesContext = aLib->av_buffer_ref(aAVCodecContext->hw_frames_ctx);
+   mHWAVBuffer = aLib->av_buffer_ref(aAVFrame->buf[0]);
+ }
+ 
+-void VideoFrameSurfaceVAAPI::ReleaseVAAPIData(bool aForFrameRecycle) {
+-  FFMPEG_LOG("VideoFrameSurfaceVAAPI: VAAPI releasing dmabuf surface UID = %d",
++void VideoFrameSurface<LIBAV_VER>::ReleaseVAAPIData(bool aForFrameRecycle) {
++  FFMPEG_LOG("VideoFrameSurface: VAAPI releasing dmabuf surface UID = %d",
+              mSurface->GetUID());
+ 
+   // It's possible to unref GPU data while IsUsed() is still set.
+@@ -67,43 +68,43 @@ void VideoFrameSurfaceVAAPI::ReleaseVAAPIData(bool aForFrameRecycle) {
+   }
+ }
+ 
+-VideoFrameSurfaceVAAPI::~VideoFrameSurfaceVAAPI() {
+-  FFMPEG_LOG("VideoFrameSurfaceVAAPI: deleting dmabuf surface UID = %d",
++VideoFrameSurface<LIBAV_VER>::~VideoFrameSurface() {
++  FFMPEG_LOG("VideoFrameSurface: deleting dmabuf surface UID = %d",
+              mSurface->GetUID());
+   // We're about to quit, no need to recycle the frames.
+   ReleaseVAAPIData(/* aForFrameRecycle */ false);
+ }
+ 
+-VideoFramePool::VideoFramePool() : mSurfaceLock("VideoFramePoolSurfaceLock") {}
++VideoFramePool<LIBAV_VER>::VideoFramePool() : mSurfaceLock("VideoFramePoolSurfaceLock") {}
+ 
+-VideoFramePool::~VideoFramePool() {
++VideoFramePool<LIBAV_VER>::~VideoFramePool() {
+   MutexAutoLock lock(mSurfaceLock);
+   mDMABufSurfaces.Clear();
+ }
+ 
+-void VideoFramePool::ReleaseUnusedVAAPIFrames() {
++void VideoFramePool<LIBAV_VER>::ReleaseUnusedVAAPIFrames() {
+   MutexAutoLock lock(mSurfaceLock);
+   for (const auto& surface : mDMABufSurfaces) {
+-    auto* vaapiSurface = surface->AsVideoFrameSurfaceVAAPI();
+-    if (!vaapiSurface->IsUsed()) {
+-      vaapiSurface->ReleaseVAAPIData();
++    if (!surface->IsUsed()) {
++      surface->ReleaseVAAPIData();
+     }
+   }
+ }
+ 
+-RefPtr<VideoFrameSurface> VideoFramePool::GetFreeVideoFrameSurface() {
++RefPtr<VideoFrameSurface<LIBAV_VER>>
++VideoFramePool<LIBAV_VER>::GetFreeVideoFrameSurface() {
+   for (auto& surface : mDMABufSurfaces) {
+     if (surface->IsUsed()) {
+       continue;
+     }
+-    auto* vaapiSurface = surface->AsVideoFrameSurfaceVAAPI();
+-    vaapiSurface->ReleaseVAAPIData();
++    surface->ReleaseVAAPIData();
+     return surface;
+   }
+   return nullptr;
+ }
+ 
+-RefPtr<VideoFrameSurface> VideoFramePool::GetVideoFrameSurface(
++RefPtr<VideoFrameSurface<LIBAV_VER>>
++VideoFramePool<LIBAV_VER>::GetVideoFrameSurface(
+     VADRMPRIMESurfaceDescriptor& aVaDesc, AVCodecContext* aAVCodecContext,
+     AVFrame* aAVFrame, FFmpegLibWrapper* aLib) {
+   if (aVaDesc.fourcc != VA_FOURCC_NV12 && aVaDesc.fourcc != VA_FOURCC_YV12 &&
+@@ -113,7 +114,7 @@ RefPtr<VideoFrameSurface> VideoFramePool::GetVideoFrameSurface(
+   }
+ 
+   MutexAutoLock lock(mSurfaceLock);
+-  RefPtr<VideoFrameSurface> videoSurface = GetFreeVideoFrameSurface();
++  RefPtr<VideoFrameSurface<LIBAV_VER>> videoSurface = GetFreeVideoFrameSurface();
+   if (!videoSurface) {
+     RefPtr<DMABufSurfaceYUV> surface =
+         DMABufSurfaceYUV::CreateYUVSurface(aVaDesc);
+@@ -121,7 +122,7 @@ RefPtr<VideoFrameSurface> VideoFramePool::GetVideoFrameSurface(
+       return nullptr;
+     }
+     FFMPEG_LOG("Created new VA-API DMABufSurface UID = %d", surface->GetUID());
+-    RefPtr<VideoFrameSurfaceVAAPI> surf = new VideoFrameSurfaceVAAPI(surface);
++    RefPtr<VideoFrameSurface<LIBAV_VER>> surf = new VideoFrameSurface<LIBAV_VER>(surface);
+     if (!mTextureCreationWorks) {
+       mTextureCreationWorks = Some(surface->VerifyTextureCreation());
+     }
+@@ -138,11 +139,8 @@ RefPtr<VideoFrameSurface> VideoFramePool::GetVideoFrameSurface(
+     }
+     FFMPEG_LOG("Reusing VA-API DMABufSurface UID = %d", surface->GetUID());
+   }
+-
+-  auto* vaapiSurface = videoSurface->AsVideoFrameSurfaceVAAPI();
+-  vaapiSurface->LockVAAPIData(aAVCodecContext, aAVFrame, aLib);
+-  vaapiSurface->MarkAsUsed();
+-
++  videoSurface->LockVAAPIData(aAVCodecContext, aAVFrame, aLib);
++  videoSurface->MarkAsUsed();
+   return videoSurface;
+ }
+ 
+diff --git a/dom/media/platforms/ffmpeg/FFmpegVideoFramePool.h b/dom/media/platforms/ffmpeg/FFmpegVideoFramePool.h
+index c506d22..c89b418 100644
+--- a/dom/media/platforms/ffmpeg/FFmpegVideoFramePool.h
++++ b/dom/media/platforms/ffmpeg/FFmpegVideoFramePool.h
+@@ -7,8 +7,9 @@
+ #ifndef __FFmpegVideoFramePool_h__
+ #define __FFmpegVideoFramePool_h__
+ 
+-#include "FFmpegVideoDecoder.h"
+ #include "FFmpegLibWrapper.h"
++#include "FFmpegLibs.h"
++#include "FFmpegLog.h"
+ 
+ #include "mozilla/layers/DMABUFSurfaceImage.h"
+ #include "mozilla/widget/DMABufLibWrapper.h"
+@@ -16,43 +17,16 @@
+ 
+ namespace mozilla {
+ 
+-class VideoFramePool;
+-class VideoFrameSurfaceVAAPI;
+-
+-class VideoFrameSurface {
+- public:
+-  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(VideoFrameSurface)
+-
+-  VideoFrameSurface() = default;
+-
+-  virtual VideoFrameSurfaceVAAPI* AsVideoFrameSurfaceVAAPI() { return nullptr; }
+-
+-  virtual void SetYUVColorSpace(gfx::YUVColorSpace aColorSpace) = 0;
+-  virtual void SetColorRange(gfx::ColorRange aColorRange) = 0;
+-
+-  virtual RefPtr<DMABufSurfaceYUV> GetDMABufSurface() { return nullptr; };
+-  virtual RefPtr<layers::Image> GetAsImage() = 0;
+-
+-  // Don't allow VideoFrameSurface plain copy as it leads to
+-  // unexpected DMABufSurface/HW buffer releases and we don't want to
+-  // deep copy them.
+-  VideoFrameSurface(const VideoFrameSurface&) = delete;
+-  const VideoFrameSurface& operator=(VideoFrameSurface const&) = delete;
+-
+- protected:
+-  virtual ~VideoFrameSurface(){};
+-};
+-
+-// VideoFrameSurfaceVAAPI holds a reference to GPU data with a video frame.
++// VideoFrameSurface holds a reference to GPU data with a video frame.
+ //
+ // Actual GPU pixel data are stored at DMABufSurface and
+ // DMABufSurface is passed to gecko GL rendering pipeline via.
+ // DMABUFSurfaceImage.
+ //
+-// VideoFrameSurfaceVAAPI can optionally hold VA-API ffmpeg related data to keep
++// VideoFrameSurface can optionally hold VA-API ffmpeg related data to keep
+ // GPU data locked untill we need them.
+ //
+-// VideoFrameSurfaceVAAPI is used for both HW accelerated video decoding
++// VideoFrameSurface is used for both HW accelerated video decoding
+ // (VA-API) and ffmpeg SW decoding.
+ //
+ // VA-API scenario
+@@ -72,13 +46,24 @@ class VideoFrameSurface {
+ // Unfortunately there isn't any obvious way how to mark particular VASurface
+ // as used. The best we can do is to hold a reference to particular AVBuffer
+ // from decoded AVFrame and AVHWFramesContext which owns the AVBuffer.
+-class VideoFrameSurfaceVAAPI final : public VideoFrameSurface {
+-  friend class VideoFramePool;
++template <int V>
++class VideoFrameSurface {};
++template <>
++class VideoFrameSurface<LIBAV_VER>;
++
++template <int V>
++class VideoFramePool {};
++template <>
++class VideoFramePool<LIBAV_VER>;
++
++template <>
++class VideoFrameSurface<LIBAV_VER> {
++  friend class VideoFramePool<LIBAV_VER>;
+ 
+  public:
+-  explicit VideoFrameSurfaceVAAPI(DMABufSurface* aSurface);
++  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(VideoFrameSurface)
+ 
+-  VideoFrameSurfaceVAAPI* AsVideoFrameSurfaceVAAPI() final { return this; }
++  explicit VideoFrameSurface(DMABufSurface* aSurface);
+ 
+   void SetYUVColorSpace(mozilla::gfx::YUVColorSpace aColorSpace) {
+     mSurface->GetAsDMABufSurfaceYUV()->SetYUVColorSpace(aColorSpace);
+@@ -93,6 +78,12 @@ class VideoFrameSurfaceVAAPI final : public VideoFrameSurface {
+ 
+   RefPtr<layers::Image> GetAsImage();
+ 
++  // Don't allow VideoFrameSurface plain copy as it leads to
++  // unexpected DMABufSurface/HW buffer releases and we don't want to
++  // deep copy them.
++  VideoFrameSurface(const VideoFrameSurface&) = delete;
++  const VideoFrameSurface& operator=(VideoFrameSurface const&) = delete;
++
+  protected:
+   // Lock VAAPI related data
+   void LockVAAPIData(AVCodecContext* aAVCodecContext, AVFrame* aAVFrame,
+@@ -107,7 +98,7 @@ class VideoFrameSurfaceVAAPI final : public VideoFrameSurface {
+   void MarkAsUsed() { mSurface->GlobalRefAdd(); }
+ 
+  private:
+-  virtual ~VideoFrameSurfaceVAAPI();
++  virtual ~VideoFrameSurface();
+ 
+   const RefPtr<DMABufSurface> mSurface;
+   const FFmpegLibWrapper* mLib;
+@@ -116,23 +107,24 @@ class VideoFrameSurfaceVAAPI final : public VideoFrameSurface {
+ };
+ 
+ // VideoFramePool class is thread-safe.
+-class VideoFramePool final {
++template <>
++class VideoFramePool<LIBAV_VER> {
+  public:
+   VideoFramePool();
+   ~VideoFramePool();
+ 
+-  RefPtr<VideoFrameSurface> GetVideoFrameSurface(
++  RefPtr<VideoFrameSurface<LIBAV_VER>> GetVideoFrameSurface(
+       VADRMPRIMESurfaceDescriptor& aVaDesc, AVCodecContext* aAVCodecContext,
+       AVFrame* aAVFrame, FFmpegLibWrapper* aLib);
+   void ReleaseUnusedVAAPIFrames();
+ 
+  private:
+-  RefPtr<VideoFrameSurface> GetFreeVideoFrameSurface();
++  RefPtr<VideoFrameSurface<LIBAV_VER>> GetFreeVideoFrameSurface();
+ 
+  private:
+   // Protect mDMABufSurfaces pool access
+   Mutex mSurfaceLock;
+-  nsTArray<RefPtr<VideoFrameSurfaceVAAPI>> mDMABufSurfaces;
++  nsTArray<RefPtr<VideoFrameSurface<LIBAV_VER>>> mDMABufSurfaces;
+   // We may fail to create texture over DMABuf memory due to driver bugs so
+   // check that before we export first DMABuf video frame.
+   Maybe<bool> mTextureCreationWorks;
+diff --git a/dom/media/platforms/ffmpeg/ffmpeg58/moz.build b/dom/media/platforms/ffmpeg/ffmpeg58/moz.build
+index de2611e..8ffdaae 100644
+--- a/dom/media/platforms/ffmpeg/ffmpeg58/moz.build
++++ b/dom/media/platforms/ffmpeg/ffmpeg58/moz.build
+@@ -30,6 +30,9 @@ if CONFIG['MOZ_WAYLAND']:
+   CXXFLAGS += CONFIG['MOZ_GTK3_CFLAGS']
+   DEFINES['MOZ_WAYLAND_USE_VAAPI'] = 1
+   USE_LIBS += ['mozva']
++  UNIFIED_SOURCES += [
++    '../FFmpegVideoFramePool.cpp',
++  ]
+ 
+ include("/ipc/chromium/chromium-config.mozbuild")
+ 
+diff --git a/dom/media/platforms/ffmpeg/ffmpeg59/moz.build b/dom/media/platforms/ffmpeg/ffmpeg59/moz.build
+index 7d28420..1da28a1 100644
+--- a/dom/media/platforms/ffmpeg/ffmpeg59/moz.build
++++ b/dom/media/platforms/ffmpeg/ffmpeg59/moz.build
+@@ -30,6 +30,9 @@ if CONFIG["MOZ_WAYLAND"]:
+     CXXFLAGS += CONFIG["MOZ_GTK3_CFLAGS"]
+     DEFINES["MOZ_WAYLAND_USE_VAAPI"] = 1
+     USE_LIBS += ["mozva"]
++    UNIFIED_SOURCES += [
++        "../FFmpegVideoFramePool.cpp",
++    ]
+ 
+ include("/ipc/chromium/chromium-config.mozbuild")
+