Add m-esr52 at 52.6.0

1 files changed, 2778 insertions, 0 deletions

diff --git a/dom/canvas/ImageBitmapUtils.cpp b/dom/canvas/ImageBitmapUtils.cpp
new file mode 100644
index 000000000..7f2f36876
--- /dev/null
+++ b/dom/canvas/ImageBitmapUtils.cpp
@@ -0,0 +1,2778 @@
+/* -*- 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 "ImageBitmapUtils.h"
+#include "ImageBitmapColorUtils.h"
+#include "ImageContainer.h"
+#include "libyuv.h"
+#include "mozilla/dom/ImageBitmapBinding.h"
+#include "mozilla/Function.h"
+#include "mozilla/gfx/2D.h"
+
+using namespace libyuv;
+using namespace mozilla::gfx;
+
+namespace mozilla {
+namespace dom {
+namespace imagebitmapformat {
+
+class Utils;
+class Utils_RGBA32;
+class Utils_BGRA32;
+class Utils_RGB24;
+class Utils_BGR24;
+class Utils_Gray8;
+class Utils_YUV444P;
+class Utils_YUV422P;
+class Utils_YUV420P;
+class Utils_YUV420SP_NV12;
+class Utils_YUV420SP_NV21;
+class Utils_HSV;
+class Utils_Lab;
+class Utils_Depth;
+
+static int GetBytesPerPixelValue(ChannelPixelLayoutDataType aDataType)
+{
+  switch (aDataType)
+  {
+  case ChannelPixelLayoutDataType::Uint8:
+    return sizeof(uint8_t);
+  case ChannelPixelLayoutDataType::Int8:
+    return sizeof(int8_t);
+  case ChannelPixelLayoutDataType::Uint16:
+    return sizeof(uint16_t);
+  case ChannelPixelLayoutDataType::Int16:
+    return sizeof(int16_t);
+  case ChannelPixelLayoutDataType::Uint32:
+    return sizeof(uint32_t);
+  case ChannelPixelLayoutDataType::Int32:
+    return sizeof(int32_t);
+  case ChannelPixelLayoutDataType::Float32:
+    return sizeof(float);
+  case ChannelPixelLayoutDataType::Float64:
+    return sizeof(double);
+  default:
+    return 0;
+  }
+}
+
+/*
+ * The UtilsUniquePtr is a UniquePtr to ImageBitmapFormatUtils with a customized
+ * deleter which does nothing. This is used as the return type of
+ * ImageBitmapFormatUtils::GetUtils to prevent users deleting the returned
+ * pointer.
+ */
+struct DoNotDelete { void operator()(void* p) {} };
+using UtilsUniquePtr = UniquePtr<Utils, DoNotDelete>;
+
+/*
+ * ImageBitmapFormatUtils is an abstract class which provides interfaces to
+ * extract information of each ImageBitmapFormat and interfaces to convert
+ * image data between different ImageBitmapFormats. For each kind of
+ * ImageBitmapFromat, we derive a subclass from the ImageBitmapFormatUtils to
+ * implement functionalities that are subject to the specific ImageBitmapFormat.
+ *
+ * ImageBitmapFormatUtils is an abstract class and its sub-classes are designed
+ * as singletons. The singleton instance of sub-classes could be initialized and
+ * accessed via the ImageBitmapFormatUtils::GetUtils() static method. The
+ * singleton instance is a static local variable which does not need to be
+ * released manually and, with the C++11 static initialization, the
+ * initialization is thread-safe.
+ *
+ * ImageBitmapFormatUtils and its sub-classes are designed to unify operations
+ * of ImageBitmap-extensions over different kinds of ImageBitmapFormats; they
+ * provide following functionalities:
+ *
+ * (1) Create default/customized ImagePixelLayout object of each kind of
+ *     ImageBitmapFormat.
+ * (2) Store the channel counts of each ImageBitmapFormat.
+ * (3) Calculate the needed buffer size of each kind of ImageBitmapFormat with
+ *     given width, height and stride.
+ * (4) Perform color conversion between supported ImageBitmapFormats. We use
+ *     _double dispatching_ to identify the source format and destination format
+ *     at run time. The _double dispatching_ here is mainly implemented by
+ *     overriding the _convertTo_ method over the ImageBitmapFormatUtils class
+ *     hierarchy and overloading the _convertFrom_ methods over all sub-classes
+ *     of ImageBitmapFormatUtils.
+ */
+class Utils
+{
+public:
+  // Get the singleton utility instance of the given ImageBitmapFormat.
+  static UtilsUniquePtr GetUtils(ImageBitmapFormat aFormat);
+
+  // Get the needed buffer size to store image data in the current
+  // ImageBitmapFormat with the given width and height.
+  // The current ImageBitmapFormat is the format used to implement the concrete
+  // subclass of which the current instance is initialized.
+  virtual uint32_t NeededBufferSize(uint32_t width, uint32_t height) = 0;
+
+  // Creates a default ImagePixelLayout object of the current ImageBitmapFormat
+  // with the given width, height and stride.
+  virtual UniquePtr<ImagePixelLayout>
+  CreateDefaultLayout(uint32_t aWidth, uint32_t aHeight, uint32_t aStride) = 0;
+
+  // Convert the source image data (stored in the aSrcBuffer and described by
+  // the aSrcLayout) from the current ImageBitmapFormat to the given
+  // ImageBitmapFormat, aDstFormat.
+  // The converted image data is stored in the aDstBuffer and described by the
+  // returned ImagePixelLayout object.
+  virtual UniquePtr<ImagePixelLayout>
+  ConvertTo(Utils* aDstFormat, const uint8_t* aSrcBuffer, const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer) = 0;
+
+  // ConvertFrom():
+  // Convert the source image data (which is in the aSrcFormat format, the pixel
+  // layout is described by the aSrcLayout and the raw data is stored in the
+  // aSrcBuffer) to the current ImageBitmapFormat.
+  // The converted image data is stored in the aDstBuffer and described by the
+  // returned ImagePixelLayout object.
+  virtual UniquePtr<ImagePixelLayout>
+  ConvertFrom(Utils_RGBA32* aSrcFormat, const uint8_t* aSrcBuffer, const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer) = 0;
+
+  virtual UniquePtr<ImagePixelLayout>
+  ConvertFrom(Utils_BGRA32* aSrcFormat, const uint8_t* aSrcBuffer, const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer) = 0;
+
+  virtual UniquePtr<ImagePixelLayout>
+  ConvertFrom(Utils_RGB24* aSrcFormat, const uint8_t* aSrcBuffer, const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer) = 0;
+
+  virtual UniquePtr<ImagePixelLayout>
+  ConvertFrom(Utils_BGR24* aSrcFormat, const uint8_t* aSrcBuffer, const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer) = 0;
+
+  virtual UniquePtr<ImagePixelLayout>
+  ConvertFrom(Utils_Gray8* aSrcFormat, const uint8_t* aSrcBuffer, const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer) = 0;
+
+  virtual UniquePtr<ImagePixelLayout>
+  ConvertFrom(Utils_YUV444P* aSrcFormat, const uint8_t* aSrcBuffer, const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer) = 0;
+
+  virtual UniquePtr<ImagePixelLayout>
+  ConvertFrom(Utils_YUV422P* aSrcFormat, const uint8_t* aSrcBuffer, const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer) = 0;
+
+  virtual UniquePtr<ImagePixelLayout>
+  ConvertFrom(Utils_YUV420P* aSrcFormat, const uint8_t* aSrcBuffer, const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer) = 0;
+
+  virtual UniquePtr<ImagePixelLayout>
+  ConvertFrom(Utils_YUV420SP_NV12* aSrcFormat, const uint8_t* aSrcBuffer, const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer) = 0;
+
+  virtual UniquePtr<ImagePixelLayout>
+  ConvertFrom(Utils_YUV420SP_NV21* aSrcFormat, const uint8_t* aSrcBuffer, const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer) = 0;
+
+  virtual UniquePtr<ImagePixelLayout>
+  ConvertFrom(Utils_HSV* aSrcFormat, const uint8_t* aSrcBuffer, const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer) = 0;
+
+  virtual UniquePtr<ImagePixelLayout>
+  ConvertFrom(Utils_Lab* aSrcFormat, const uint8_t* aSrcBuffer, const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer) = 0;
+
+  virtual UniquePtr<ImagePixelLayout>
+  ConvertFrom(Utils_Depth* aSrcFormat, const uint8_t* aSrcBuffer, const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer) = 0;
+
+  // Check whether or not the current ImageBitmapFormat can be converted from
+  // the given ImageBitmapFormat.
+  virtual bool
+  CanConvertFrom(ImageBitmapFormat aSrcFormat) = 0;
+
+  // Get the number of channels.
+  uint8_t GetChannelCount() const
+  {
+    return mChannels;
+  }
+
+protected:
+  Utils(uint32_t aChannels,
+                         ChannelPixelLayoutDataType aDataType)
+  : mChannels(aChannels)
+  , mBytesPerPixelValue(GetBytesPerPixelValue(aDataType))
+  , mDataType(aDataType)
+  {
+  }
+
+  virtual ~Utils()
+  {
+  }
+
+  const uint8_t mChannels;
+  const int mBytesPerPixelValue;
+  const ChannelPixelLayoutDataType mDataType;
+};
+
+#define DECLARE_Utils(NAME)                          \
+class Utils_ ## NAME : public Utils \
+{                                                                     \
+private:                                                              \
+  explicit Utils_ ## NAME ();                        \
+  ~Utils_ ## NAME () = default;                      \
+  Utils_ ## NAME (Utils_ ## NAME const &) = delete;             \
+  Utils_ ## NAME (Utils_ ## NAME &&) = delete;                  \
+  Utils_ ## NAME & operator=(Utils_ ## NAME const &) = delete;  \
+  Utils_ ## NAME & operator=(Utils_ ## NAME &&) = delete;       \
+                                                                                                  \
+public:                                                     \
+  static Utils_ ## NAME & GetInstance();   \
+                                                            \
+  virtual uint32_t NeededBufferSize(uint32_t aWidth, uint32_t aHeight) override;  \
+                                                                                  \
+  virtual UniquePtr<ImagePixelLayout>                          \
+  CreateDefaultLayout(uint32_t, uint32_t, uint32_t) override;  \
+                                                               \
+  virtual UniquePtr<ImagePixelLayout>                                                             \
+  ConvertTo(Utils*, const uint8_t*, const ImagePixelLayout*, uint8_t*) override; \
+                                                                                                  \
+  virtual UniquePtr<ImagePixelLayout>                                                                       \
+  ConvertFrom(Utils_RGBA32*, const uint8_t*, const ImagePixelLayout*, uint8_t*) override;  \
+                                                                                                            \
+  virtual UniquePtr<ImagePixelLayout>                                                                       \
+  ConvertFrom(Utils_BGRA32*, const uint8_t*, const ImagePixelLayout*, uint8_t*) override;  \
+                                                                                                            \
+  virtual UniquePtr<ImagePixelLayout>                                                                     \
+  ConvertFrom(Utils_RGB24*, const uint8_t*, const ImagePixelLayout*, uint8_t*) override; \
+                                                                                                          \
+  virtual UniquePtr<ImagePixelLayout>                                                                     \
+  ConvertFrom(Utils_BGR24*, const uint8_t*, const ImagePixelLayout*, uint8_t*) override; \
+                                                                                                          \
+  virtual UniquePtr<ImagePixelLayout>                                                                     \
+  ConvertFrom(Utils_Gray8*, const uint8_t*, const ImagePixelLayout*, uint8_t*) override; \
+                                                                                                          \
+  virtual UniquePtr<ImagePixelLayout>                                                                       \
+  ConvertFrom(Utils_YUV444P*, const uint8_t*, const ImagePixelLayout*, uint8_t*) override; \
+                                                                                                            \
+  virtual UniquePtr<ImagePixelLayout>                                                                       \
+  ConvertFrom(Utils_YUV422P*, const uint8_t*, const ImagePixelLayout*, uint8_t*) override; \
+                                                                                                            \
+  virtual UniquePtr<ImagePixelLayout>                                                                       \
+  ConvertFrom(Utils_YUV420P*, const uint8_t*, const ImagePixelLayout*, uint8_t*) override; \
+                                                                                                            \
+  virtual UniquePtr<ImagePixelLayout>                                                                             \
+  ConvertFrom(Utils_YUV420SP_NV12*, const uint8_t*, const ImagePixelLayout*, uint8_t*) override; \
+                                                                                                                  \
+  virtual UniquePtr<ImagePixelLayout>                                                                             \
+  ConvertFrom(Utils_YUV420SP_NV21*, const uint8_t*, const ImagePixelLayout*, uint8_t*) override; \
+                                                                                                                  \
+  virtual UniquePtr<ImagePixelLayout>                                                                   \
+  ConvertFrom(Utils_HSV*, const uint8_t*, const ImagePixelLayout*, uint8_t*) override; \
+                                                                                                        \
+  virtual UniquePtr<ImagePixelLayout>                                                                   \
+  ConvertFrom(Utils_Lab*, const uint8_t*, const ImagePixelLayout*, uint8_t*) override; \
+                                                                                                        \
+  virtual UniquePtr<ImagePixelLayout>                                                                     \
+  ConvertFrom(Utils_Depth*, const uint8_t*, const ImagePixelLayout*, uint8_t*) override; \
+                                                                                                          \
+  virtual bool                                  \
+  CanConvertFrom(ImageBitmapFormat) override;   \
+};
+
+DECLARE_Utils(RGBA32)
+DECLARE_Utils(BGRA32)
+DECLARE_Utils(RGB24)
+DECLARE_Utils(BGR24)
+DECLARE_Utils(Gray8)
+DECLARE_Utils(YUV444P)
+DECLARE_Utils(YUV422P)
+DECLARE_Utils(YUV420P)
+DECLARE_Utils(YUV420SP_NV12)
+DECLARE_Utils(YUV420SP_NV21)
+DECLARE_Utils(HSV)
+DECLARE_Utils(Lab)
+DECLARE_Utils(Depth)
+
+#undef DECLARE_Utils
+
+/*
+ * ImageBitmapFormatUtils.
+ */
+/* static */ UtilsUniquePtr
+Utils::GetUtils(ImageBitmapFormat aFormat)
+{
+  switch(aFormat)
+  {
+  case ImageBitmapFormat::RGBA32:
+    return UtilsUniquePtr(&Utils_RGBA32::GetInstance());
+  case ImageBitmapFormat::BGRA32:
+    return UtilsUniquePtr(&Utils_BGRA32::GetInstance());
+  case ImageBitmapFormat::RGB24:
+    return UtilsUniquePtr(&Utils_RGB24::GetInstance());
+  case ImageBitmapFormat::BGR24:
+    return UtilsUniquePtr(&Utils_BGR24::GetInstance());
+  case ImageBitmapFormat::GRAY8:
+    return UtilsUniquePtr(&Utils_Gray8::GetInstance());
+  case ImageBitmapFormat::YUV444P:
+    return UtilsUniquePtr(&Utils_YUV444P::GetInstance());
+  case ImageBitmapFormat::YUV422P:
+    return UtilsUniquePtr(&Utils_YUV422P::GetInstance());
+  case ImageBitmapFormat::YUV420P:
+    return UtilsUniquePtr(&Utils_YUV420P::GetInstance());
+  case ImageBitmapFormat::YUV420SP_NV12:
+    return UtilsUniquePtr(&Utils_YUV420SP_NV12::GetInstance());
+  case ImageBitmapFormat::YUV420SP_NV21:
+    return UtilsUniquePtr(&Utils_YUV420SP_NV21::GetInstance());
+  case ImageBitmapFormat::HSV:
+    return UtilsUniquePtr(&Utils_HSV::GetInstance());
+  case ImageBitmapFormat::Lab:
+    return UtilsUniquePtr(&Utils_Lab::GetInstance());
+  case ImageBitmapFormat::DEPTH:
+    return UtilsUniquePtr(&Utils_Depth::GetInstance());
+  default:
+    return nullptr;
+  }
+}
+
+/*
+ * Helper functions.
+ */
+template<typename SrcType, typename DstType>
+static UniquePtr<ImagePixelLayout>
+CvtSimpleImgToSimpleImg(Utils* aSrcUtils, const SrcType* aSrcBuffer,
+                        const ImagePixelLayout* aSrcLayout, DstType* aDstBuffer,
+                        ImageBitmapFormat aDstFormat, int aDstChannelCount,
+                        mozilla::function<int (const SrcType*, int, DstType*, int, int, int)> converter)
+{
+  MOZ_ASSERT(aSrcUtils, "Convert color from a null utility object.");
+  MOZ_ASSERT(aSrcBuffer, "Convert color from a null buffer.");
+  MOZ_ASSERT(aSrcLayout, "Convert color from a null layout.");
+  MOZ_ASSERT(aDstBuffer, "Convert color to a null buffer.");
+
+  const nsTArray<ChannelPixelLayout>& channels = *aSrcLayout;
+  MOZ_ASSERT(channels.Length() == aSrcUtils->GetChannelCount(),
+             "The channel count is wrong.");
+
+  const int dstStride = channels[0].mWidth * aDstChannelCount * sizeof(DstType);
+  int rv = converter(aSrcBuffer, channels[0].mStride,
+                     aDstBuffer, dstStride,
+                     channels[0].mWidth, channels[0].mHeight);
+
+  if (NS_WARN_IF(rv != 0)) {
+    return nullptr;
+  }
+
+  return CreateDefaultPixelLayout(aDstFormat, channels[0].mWidth,
+                                  channels[0].mHeight, dstStride);
+}
+
+static UniquePtr<ImagePixelLayout>
+CvtYUVImgToSimpleImg(Utils* aSrcUtils, const uint8_t* aSrcBuffer,
+                     const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer,
+                     ImageBitmapFormat aDstFormat, int aDstChannelCount,
+                     mozilla::function<int (const uint8_t*, int, const uint8_t*, int, const uint8_t*, int, uint8_t*, int, int, int)> converter)
+{
+  MOZ_ASSERT(aSrcUtils, "Convert color from a null utility object.");
+  MOZ_ASSERT(aSrcBuffer, "Convert color from a null buffer.");
+  MOZ_ASSERT(aSrcLayout, "Convert color from a null layout.");
+  MOZ_ASSERT(aDstBuffer, "Convert color to a null buffer.");
+
+  const nsTArray<ChannelPixelLayout>& channels = *aSrcLayout;
+  MOZ_ASSERT(channels.Length() == aSrcUtils->GetChannelCount(),
+             "The channel count is wrong.");
+
+  const int dstStride = channels[0].mWidth * aDstChannelCount * sizeof(uint8_t);
+  int rv = converter(aSrcBuffer + channels[0].mOffset, channels[0].mStride,
+                     aSrcBuffer + channels[1].mOffset, channels[1].mStride,
+                     aSrcBuffer + channels[2].mOffset, channels[2].mStride,
+                     aDstBuffer, dstStride,
+                     channels[0].mWidth, channels[0].mHeight);
+
+  if (NS_WARN_IF(rv != 0)) {
+    return nullptr;
+  }
+
+  return CreateDefaultPixelLayout(aDstFormat, channels[0].mWidth,
+                                  channels[0].mHeight, dstStride);
+}
+
+static UniquePtr<ImagePixelLayout>
+CvtNVImgToSimpleImg(Utils* aSrcUtils, const uint8_t* aSrcBuffer,
+                    const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer,
+                    ImageBitmapFormat aDstFormat, int aDstChannelCount,
+                    mozilla::function<int (const uint8_t*, int, const uint8_t*, int, uint8_t*, int, int, int)> converter)
+{
+  MOZ_ASSERT(aSrcUtils, "Convert color from a null utility object.");
+  MOZ_ASSERT(aSrcBuffer, "Convert color from a null buffer.");
+  MOZ_ASSERT(aSrcLayout, "Convert color from a null layout.");
+  MOZ_ASSERT(aDstBuffer, "Convert color to a null buffer.");
+
+  const nsTArray<ChannelPixelLayout>& channels = *aSrcLayout;
+  MOZ_ASSERT(channels.Length() == aSrcUtils->GetChannelCount(),
+             "The channel count is wrong.");
+
+  const int dstStride = channels[0].mWidth * aDstChannelCount * sizeof(uint8_t);
+  int rv = converter(aSrcBuffer + channels[0].mOffset, channels[0].mStride,
+                     aSrcBuffer + channels[1].mOffset, channels[1].mStride,
+                     aDstBuffer, dstStride,
+                     channels[0].mWidth, channels[0].mHeight);
+
+  if (NS_WARN_IF(rv != 0)) {
+    return nullptr;
+  }
+
+  return CreateDefaultPixelLayout(aDstFormat, channels[0].mWidth,
+                                  channels[0].mHeight, dstStride);
+}
+
+static UniquePtr<ImagePixelLayout>
+CvtSimpleImgToYUVImg(Utils* aSrcUtils, const uint8_t* aSrcBuffer,
+                     const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer,
+                     ImageBitmapFormat aDstFormat,
+                     mozilla::function<int (const uint8_t*, int, uint8_t*, int, uint8_t*, int, uint8_t*, int, int, int)> converter)
+{
+  MOZ_ASSERT(aSrcUtils, "Convert color from a null utility object.");
+  MOZ_ASSERT(aSrcBuffer, "Convert color from a null buffer.");
+  MOZ_ASSERT(aSrcLayout, "Convert color from a null layout.");
+  MOZ_ASSERT(aDstBuffer, "Convert color to a null buffer.");
+
+  UniquePtr<ImagePixelLayout> layout =
+    CreateDefaultPixelLayout(aDstFormat, (*aSrcLayout)[0].mWidth,
+                             (*aSrcLayout)[0].mHeight, (*aSrcLayout)[0].mWidth);
+
+  MOZ_ASSERT(layout, "Cannot create a ImagePixelLayout.");
+
+  const nsTArray<ChannelPixelLayout>& channels = *layout;
+
+  int rv = converter(aSrcBuffer, (*aSrcLayout)[0].mStride,
+                     aDstBuffer + channels[0].mOffset, channels[0].mStride,
+                     aDstBuffer + channels[1].mOffset, channels[1].mStride,
+                     aDstBuffer + channels[2].mOffset, channels[2].mStride,
+                     channels[0].mWidth, channels[0].mHeight);
+
+  if (NS_WARN_IF(rv != 0)) {
+    return nullptr;
+  }
+
+  return layout;
+}
+
+static UniquePtr<ImagePixelLayout>
+CvtSimpleImgToNVImg(Utils* aSrcUtils, const uint8_t* aSrcBuffer,
+                    const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer,
+                    ImageBitmapFormat aDstFormat,
+                    mozilla::function<int (const uint8_t*, int, uint8_t*, int, uint8_t*, int, int, int)> converter)
+{
+  MOZ_ASSERT(aSrcUtils, "Convert color from a null utility object.");
+  MOZ_ASSERT(aSrcBuffer, "Convert color from a null buffer.");
+  MOZ_ASSERT(aSrcLayout, "Convert color from a null layout.");
+  MOZ_ASSERT(aDstBuffer, "Convert color to a null buffer.");
+
+  UniquePtr<ImagePixelLayout> layout =
+    CreateDefaultPixelLayout(aDstFormat, (*aSrcLayout)[0].mWidth,
+                             (*aSrcLayout)[0].mHeight, (*aSrcLayout)[0].mWidth);
+
+  MOZ_ASSERT(layout, "Cannot create a ImagePixelLayout.");
+
+  const nsTArray<ChannelPixelLayout>& channels = *layout;
+
+  int rv = converter(aSrcBuffer, (*aSrcLayout)[0].mStride,
+                     aDstBuffer + channels[0].mOffset, channels[0].mStride,
+                     aDstBuffer + channels[1].mOffset, channels[1].mStride,
+                     channels[0].mWidth, channels[0].mHeight);
+
+  if (NS_WARN_IF(rv != 0)) {
+    return nullptr;
+  }
+
+  return layout;
+}
+
+template<class SrcUtilsType, class DstUtilsType>
+static UniquePtr<ImagePixelLayout>
+TwoPassConversion(SrcUtilsType* aSrcUtils, const uint8_t* aSrcBuffer,
+                  const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer,
+                  ImageBitmapFormat aMiddleFormat, DstUtilsType* aDstUtils)
+{
+  MOZ_ASSERT(aSrcUtils, "Convert color from a null source utility.");
+  MOZ_ASSERT(aSrcBuffer, "Convert color from a null buffer.");
+  MOZ_ASSERT(aSrcLayout, "Convert color from a null layout.");
+  MOZ_ASSERT(aDstBuffer, "Convert color to a null buffer.");
+
+  // I444 -> I420 -> I422
+  UtilsUniquePtr yuv420PUtils = Utils::GetUtils(aMiddleFormat);
+  UniquePtr<uint8_t> yuv420PBuffer(new uint8_t[yuv420PUtils->NeededBufferSize((*aSrcLayout)[0].mWidth, (*aSrcLayout)[0].mHeight)]);
+  UniquePtr<ImagePixelLayout> yuv420PLayout = yuv420PUtils->ConvertFrom(aSrcUtils, aSrcBuffer, aSrcLayout, yuv420PBuffer.get());
+  return yuv420PUtils->ConvertTo(aDstUtils, yuv420PBuffer.get(), yuv420PLayout.get(), aDstBuffer);
+}
+
+static UniquePtr<ImagePixelLayout>
+PureCopy(Utils* aSrcUtils, const uint8_t* aSrcBuffer,
+         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer,
+         ImageBitmapFormat aDstFormat)
+{
+  MOZ_ASSERT(aSrcUtils, "Convert color from a null utility object.");
+  MOZ_ASSERT(aSrcBuffer, "Convert color from a null buffer.");
+  MOZ_ASSERT(aSrcLayout, "Convert color from a null layout.");
+  MOZ_ASSERT(aDstBuffer, "Convert color to a null buffer.");
+
+  const nsTArray<ChannelPixelLayout>& channels = *aSrcLayout;
+  MOZ_ASSERT(channels.Length() == aSrcUtils->GetChannelCount(),
+             "The channel count is wrong.");
+
+
+  uint32_t length = 0;
+
+  if (aDstFormat == ImageBitmapFormat::RGBA32 ||
+      aDstFormat == ImageBitmapFormat::BGRA32 ||
+      aDstFormat == ImageBitmapFormat::RGB24 ||
+      aDstFormat == ImageBitmapFormat::BGR24 ||
+      aDstFormat == ImageBitmapFormat::GRAY8 ||
+      aDstFormat == ImageBitmapFormat::HSV ||
+      aDstFormat == ImageBitmapFormat::Lab ||
+      aDstFormat == ImageBitmapFormat::DEPTH) {
+    length = channels[0].mHeight * channels[0].mStride;
+  } else if (aDstFormat == ImageBitmapFormat::YUV444P ||
+             aDstFormat == ImageBitmapFormat::YUV422P ||
+             aDstFormat == ImageBitmapFormat::YUV420P) {
+    length = channels[0].mHeight * channels[0].mStride +
+             channels[1].mHeight * channels[1].mStride +
+             channels[2].mHeight * channels[2].mStride;
+  } else if (aDstFormat == ImageBitmapFormat::YUV420SP_NV12 ||
+             aDstFormat == ImageBitmapFormat::YUV420SP_NV21) {
+    length = channels[0].mHeight * channels[0].mStride +
+             channels[1].mHeight * channels[1].mStride;
+  }
+
+  memcpy(aDstBuffer, aSrcBuffer, length);
+
+  UniquePtr<ImagePixelLayout> layout(new ImagePixelLayout(*aSrcLayout));
+  return layout;
+}
+
+UniquePtr<ImagePixelLayout>
+CreateDefaultLayoutForSimpleImage(uint32_t aWidth, uint32_t aHeight,
+                                  uint32_t aStride, int aChannels,
+                                  int aBytesPerPixelValue,
+                                  ChannelPixelLayoutDataType aDataType)
+{
+  UniquePtr<ImagePixelLayout> layout(new ImagePixelLayout(aChannels));
+
+  // set mChannels
+  for (uint8_t i = 0; i < aChannels; ++i) {
+    ChannelPixelLayout* channel = layout->AppendElement();
+    channel->mOffset = i * aBytesPerPixelValue;
+    channel->mWidth = aWidth;
+    channel->mHeight = aHeight;
+    channel->mDataType = aDataType; //ChannelPixelLayoutDataType::Uint8;
+    channel->mStride = aStride;
+    channel->mSkip = aChannels - 1;
+  }
+
+  return layout;
+}
+
+/*
+ * Utils_RGBA32.
+ */
+/* static */Utils_RGBA32&
+Utils_RGBA32::GetInstance()
+{
+  static Utils_RGBA32 instance;
+  return instance;
+}
+
+Utils_RGBA32::Utils_RGBA32()
+: Utils(4, ChannelPixelLayoutDataType::Uint8)
+{
+}
+
+uint32_t
+Utils_RGBA32::NeededBufferSize(uint32_t aWidth, uint32_t aHeight)
+{
+  return aWidth * aHeight * (uint32_t)mChannels * mBytesPerPixelValue;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGBA32::ConvertTo(Utils* aDstFormat, const uint8_t* aSrcBuffer,
+                        const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return aDstFormat->ConvertFrom(this, aSrcBuffer, aSrcLayout, aDstBuffer);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGBA32::ConvertFrom(Utils_RGBA32* aSrcUtils, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return PureCopy(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGBA32);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGBA32::ConvertFrom(Utils_BGRA32* aSrcFormat, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, uint8_t>(aSrcFormat, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGBA32, 4, &libyuv::ABGRToARGB);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGBA32::ConvertFrom(Utils_RGB24* aSrcFormat, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, uint8_t>(aSrcFormat, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGBA32, 4, &RGB24ToRGBA32);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGBA32::ConvertFrom(Utils_BGR24* aSrcFormat, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, uint8_t>(aSrcFormat, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGBA32, 4, &BGR24ToRGBA32);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGBA32::ConvertFrom(Utils_Gray8* aSrcFormat, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGBA32::ConvertFrom(Utils_YUV444P* aSrcUtils, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtYUVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGBA32, 4, &YUV444PToRGBA32);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGBA32::ConvertFrom(Utils_YUV422P* aSrcUtils, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtYUVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGBA32, 4, &YUV422PToRGBA32);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGBA32::ConvertFrom(Utils_YUV420P* aSrcUtils, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtYUVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGBA32, 4, &libyuv::I420ToABGR);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGBA32::ConvertFrom(Utils_YUV420SP_NV12* aSrcUtils, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtNVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGBA32, 4, &NV12ToRGBA32);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGBA32::ConvertFrom(Utils_YUV420SP_NV21* aSrcUtils, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtNVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGBA32, 4, &NV21ToRGBA32);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGBA32::ConvertFrom(Utils_HSV* aSrcFormat, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<float, uint8_t>(aSrcFormat, (const float*)aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGBA32, 4, &HSVToRGBA32);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGBA32::ConvertFrom(Utils_Lab* aSrcFormat, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<float, uint8_t>(aSrcFormat, (const float*)aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGBA32, 4, &LabToRGBA32);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGBA32::ConvertFrom(Utils_Depth* aSrcFormat, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+bool
+Utils_RGBA32::CanConvertFrom(ImageBitmapFormat aSrcFormat)
+{
+  if (aSrcFormat == ImageBitmapFormat::GRAY8 ||
+      aSrcFormat == ImageBitmapFormat::DEPTH) {
+    return false;
+  }
+
+  return true;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGBA32::CreateDefaultLayout(uint32_t aWidth, uint32_t aHeight, uint32_t aStride)
+{
+  return CreateDefaultLayoutForSimpleImage(aWidth, aHeight, aStride, mChannels, mBytesPerPixelValue, mDataType);
+}
+
+/*
+ * Utils_BGRA32.
+ */
+/* static */Utils_BGRA32&
+Utils_BGRA32::GetInstance()
+{
+  static Utils_BGRA32 instance;
+  return instance;
+}
+
+Utils_BGRA32::Utils_BGRA32()
+: Utils(4, ChannelPixelLayoutDataType::Uint8)
+{
+}
+
+uint32_t
+Utils_BGRA32::NeededBufferSize(uint32_t aWidth, uint32_t aHeight)
+{
+  return aWidth * aHeight * (uint32_t)mChannels * mBytesPerPixelValue;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGRA32::ConvertTo(Utils* aDstFormat, const uint8_t* aSrcBuffer,
+                        const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return aDstFormat->ConvertFrom(this, aSrcBuffer, aSrcLayout, aDstBuffer);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGRA32::ConvertFrom(Utils_RGBA32* aSrcFormat, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, uint8_t>(aSrcFormat, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGRA32, 4, &libyuv::ABGRToARGB);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGRA32::ConvertFrom(Utils_BGRA32* aSrcUtils, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return PureCopy(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGRA32);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGRA32::ConvertFrom(Utils_RGB24* aSrcFormat, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, uint8_t>(aSrcFormat, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGRA32, 4, &RGB24ToBGRA32);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGRA32::ConvertFrom(Utils_BGR24* aSrcFormat, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, uint8_t>(aSrcFormat, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGRA32, 4, &BGR24ToBGRA32);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGRA32::ConvertFrom(Utils_Gray8* aSrcFormat, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGRA32::ConvertFrom(Utils_YUV444P* aSrcUtils, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtYUVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGRA32, 4, &YUV444PToBGRA32);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGRA32::ConvertFrom(Utils_YUV422P* aSrcUtils, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtYUVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGRA32, 4, &libyuv::I422ToARGB);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGRA32::ConvertFrom(Utils_YUV420P* aSrcUtils, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtYUVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGRA32, 4, &libyuv::I420ToARGB);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGRA32::ConvertFrom(Utils_YUV420SP_NV12* aSrcUtils, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtNVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGRA32, 4, &libyuv::NV12ToARGB);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGRA32::ConvertFrom(Utils_YUV420SP_NV21* aSrcUtils, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtNVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGRA32, 4, &libyuv::NV21ToARGB);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGRA32::ConvertFrom(Utils_HSV* aSrcFormat, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<float, uint8_t>(aSrcFormat, (const float*)aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGRA32, 4, &HSVToBGRA32);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGRA32::ConvertFrom(Utils_Lab* aSrcFormat, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<float, uint8_t>(aSrcFormat, (const float*)aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGRA32, 4, &LabToBGRA32);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGRA32::ConvertFrom(Utils_Depth* aSrcFormat, const uint8_t* aSrcBuffer,
+                          const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+bool
+Utils_BGRA32::CanConvertFrom(ImageBitmapFormat aSrcFormat)
+{
+  if (aSrcFormat == ImageBitmapFormat::RGBA32 ||
+      aSrcFormat == ImageBitmapFormat::BGRA32 ||
+      aSrcFormat == ImageBitmapFormat::YUV420P) {
+    return true;
+  }
+
+  return false;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGRA32::CreateDefaultLayout(uint32_t aWidth, uint32_t aHeight, uint32_t aStride)
+{
+  return CreateDefaultLayoutForSimpleImage(aWidth, aHeight, aStride, mChannels, mBytesPerPixelValue, mDataType);
+}
+
+/*
+ * Utils_RGB24.
+ */
+/* static */Utils_RGB24&
+Utils_RGB24::GetInstance()
+{
+  static Utils_RGB24 instance;
+  return instance;
+}
+
+Utils_RGB24::Utils_RGB24()
+: Utils(3, ChannelPixelLayoutDataType::Uint8)
+{
+}
+
+uint32_t
+Utils_RGB24::NeededBufferSize(uint32_t aWidth, uint32_t aHeight)
+{
+  return aWidth * aHeight * (uint32_t)mChannels * mBytesPerPixelValue;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGB24::ConvertTo(Utils* aDstFormat, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return aDstFormat->ConvertFrom(this, aSrcBuffer, aSrcLayout, aDstBuffer);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGB24::ConvertFrom(Utils_RGBA32* aSrcFormat, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, uint8_t>(aSrcFormat, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, 3, &RGBA32ToRGB24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGB24::ConvertFrom(Utils_BGRA32* aSrcFormat, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, uint8_t>(aSrcFormat, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, 3, &BGRA32ToRGB24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGB24::ConvertFrom(Utils_RGB24* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return PureCopy(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGB24::ConvertFrom(Utils_BGR24* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, uint8_t>(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, 3, &BGR24ToRGB24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGB24::ConvertFrom(Utils_Gray8* aSrcFormat, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGB24::ConvertFrom(Utils_YUV444P* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtYUVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, 3, &YUV444PToRGB24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGB24::ConvertFrom(Utils_YUV422P* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtYUVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, 3, &YUV422PToRGB24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGB24::ConvertFrom(Utils_YUV420P* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtYUVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, 3, &YUV420PToRGB24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGB24::ConvertFrom(Utils_YUV420SP_NV12* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtNVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, 3, &NV12ToRGB24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGB24::ConvertFrom(Utils_YUV420SP_NV21* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtNVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, 3, &NV21ToRGB24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGB24::ConvertFrom(Utils_HSV* aSrcFormat, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<float, uint8_t>(aSrcFormat, (const float*)aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, 3, &HSVToRGB24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGB24::ConvertFrom(Utils_Lab* aSrcFormat, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<float, uint8_t>(aSrcFormat, (const float*)aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, 3, &LabToRGB24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGB24::ConvertFrom(Utils_Depth* aSrcFormat, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+bool
+Utils_RGB24::CanConvertFrom(ImageBitmapFormat aSrcFormat)
+{
+  if (aSrcFormat == ImageBitmapFormat::GRAY8 ||
+      aSrcFormat == ImageBitmapFormat::DEPTH) {
+    return false;
+  }
+
+  return true;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_RGB24::CreateDefaultLayout(uint32_t aWidth, uint32_t aHeight, uint32_t aStride)
+{
+  return CreateDefaultLayoutForSimpleImage(aWidth, aHeight, aStride, mChannels, mBytesPerPixelValue, mDataType);
+}
+
+/*
+ * Utils_BGR24.
+ */
+/* static */Utils_BGR24&
+Utils_BGR24::GetInstance()
+{
+  static Utils_BGR24 instance;
+  return instance;
+}
+
+Utils_BGR24::Utils_BGR24()
+: Utils(3, ChannelPixelLayoutDataType::Uint8)
+{
+}
+
+uint32_t
+Utils_BGR24::NeededBufferSize(uint32_t aWidth, uint32_t aHeight)
+{
+  return aWidth * aHeight * (uint32_t)mChannels * mBytesPerPixelValue;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGR24::ConvertTo(Utils* aDstFormat, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return aDstFormat->ConvertFrom(this, aSrcBuffer, aSrcLayout, aDstBuffer);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGR24::ConvertFrom(Utils_RGBA32* aSrcFormat, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, uint8_t>(aSrcFormat, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGR24, 3, &RGBA32ToBGR24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGR24::ConvertFrom(Utils_BGRA32* aSrcFormat, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, uint8_t>(aSrcFormat, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGR24, 3, &BGRA32ToBGR24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGR24::ConvertFrom(Utils_RGB24* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, uint8_t>(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGR24, 3, &RGB24ToBGR24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGR24::ConvertFrom(Utils_BGR24* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return PureCopy(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGR24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGR24::ConvertFrom(Utils_Gray8* aSrcFormat, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGR24::ConvertFrom(Utils_YUV444P* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtYUVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGR24, 3, &YUV444PToBGR24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGR24::ConvertFrom(Utils_YUV422P* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtYUVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGR24, 3, &YUV422PToBGR24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGR24::ConvertFrom(Utils_YUV420P* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtYUVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGR24, 3, &YUV420PToBGR24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGR24::ConvertFrom(Utils_YUV420SP_NV12* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtNVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGR24, 3, &NV12ToBGR24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGR24::ConvertFrom(Utils_YUV420SP_NV21* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtNVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGR24, 3, &NV21ToBGR24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGR24::ConvertFrom(Utils_HSV* aSrcFormat, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<float, uint8_t>(aSrcFormat, (const float*)aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGR24, 3, &HSVToBGR24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGR24::ConvertFrom(Utils_Lab* aSrcFormat, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<float, uint8_t>(aSrcFormat, (const float*)aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::BGR24, 3, &LabToBGR24);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGR24::ConvertFrom(Utils_Depth* aSrcFormat, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+bool
+Utils_BGR24::CanConvertFrom(ImageBitmapFormat aSrcFormat)
+{
+  if (aSrcFormat == ImageBitmapFormat::GRAY8 ||
+      aSrcFormat == ImageBitmapFormat::DEPTH) {
+    return false;
+  }
+
+  return true;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_BGR24::CreateDefaultLayout(uint32_t aWidth, uint32_t aHeight, uint32_t aStride)
+{
+  return CreateDefaultLayoutForSimpleImage(aWidth, aHeight, aStride, mChannels, mBytesPerPixelValue, mDataType);
+}
+
+/*
+ * Utils_Gray8.
+ */
+/* static */Utils_Gray8&
+Utils_Gray8::GetInstance()
+{
+  static Utils_Gray8 instance;
+  return instance;
+}
+
+Utils_Gray8::Utils_Gray8()
+: Utils(1, ChannelPixelLayoutDataType::Uint8)
+{
+}
+
+uint32_t
+Utils_Gray8::NeededBufferSize(uint32_t aWidth, uint32_t aHeight)
+{
+  return aWidth * aHeight * (uint32_t)mChannels * mBytesPerPixelValue;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Gray8::ConvertTo(Utils* aDstFormat, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return aDstFormat->ConvertFrom(this, aSrcBuffer, aSrcLayout, aDstBuffer);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Gray8::ConvertFrom(Utils_RGBA32* aSrcFormat, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, uint8_t>(aSrcFormat, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::GRAY8, 1, &RGBA32ToGray8);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Gray8::ConvertFrom(Utils_BGRA32* aSrcFormat, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, uint8_t>(aSrcFormat, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::GRAY8, 1, &BGRA32ToGray8);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Gray8::ConvertFrom(Utils_RGB24* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, uint8_t>(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::GRAY8, 1, &RGB24ToGray8);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Gray8::ConvertFrom(Utils_BGR24* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, uint8_t>(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::GRAY8, 1, &BGR24ToGray8);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Gray8::ConvertFrom(Utils_Gray8* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return PureCopy(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::GRAY8);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Gray8::ConvertFrom(Utils_YUV444P* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtYUVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::GRAY8, 1, &YUV444PToGray8);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Gray8::ConvertFrom(Utils_YUV422P* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtYUVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::GRAY8, 1, &YUV422PToGray8);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Gray8::ConvertFrom(Utils_YUV420P* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtYUVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::GRAY8, 1, &YUV420PToGray8);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Gray8::ConvertFrom(Utils_YUV420SP_NV12* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtNVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::GRAY8, 1, &NV12ToGray8);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Gray8::ConvertFrom(Utils_YUV420SP_NV21* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtNVImgToSimpleImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::GRAY8, 1, &NV21ToGray8);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Gray8::ConvertFrom(Utils_HSV* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Gray8::ConvertFrom(Utils_Lab* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Gray8::ConvertFrom(Utils_Depth* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+bool
+Utils_Gray8::CanConvertFrom(ImageBitmapFormat aSrcFormat)
+{
+  if (aSrcFormat == ImageBitmapFormat::DEPTH) {
+    return false;
+  }
+
+  return true;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Gray8::CreateDefaultLayout(uint32_t aWidth, uint32_t aHeight, uint32_t aStride)
+{
+  return CreateDefaultLayoutForSimpleImage(aWidth, aHeight, aStride, mChannels, mBytesPerPixelValue, mDataType);
+}
+
+/*
+ * class Utils_YUV444P.
+ */
+/* static */Utils_YUV444P&
+Utils_YUV444P::GetInstance()
+{
+  static Utils_YUV444P instance;
+  return instance;
+}
+
+Utils_YUV444P::Utils_YUV444P()
+: Utils(3, ChannelPixelLayoutDataType::Uint8)
+{
+}
+
+uint32_t
+Utils_YUV444P::NeededBufferSize(uint32_t aWidth, uint32_t aHeight)
+{
+  return aWidth * aHeight * (uint32_t)mChannels * mBytesPerPixelValue;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV444P::ConvertTo(Utils* aDstFormat, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return aDstFormat->ConvertFrom(this, aSrcBuffer, aSrcLayout, aDstBuffer);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV444P::ConvertFrom(Utils_RGBA32* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToYUVImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV444P, &RGBA32ToYUV444P);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV444P::ConvertFrom(Utils_BGRA32* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToYUVImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV444P, &libyuv::ARGBToI444);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV444P::ConvertFrom(Utils_RGB24* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToYUVImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV444P, &RGB24ToYUV444P);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV444P::ConvertFrom(Utils_BGR24* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToYUVImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV444P, &BGR24ToYUV444P);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV444P::ConvertFrom(Utils_Gray8* aSrcFormat, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV444P::ConvertFrom(Utils_YUV444P* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return PureCopy(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV444P);
+}
+
+// TODO: optimize me.
+UniquePtr<ImagePixelLayout>
+Utils_YUV444P::ConvertFrom(Utils_YUV422P* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420P, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV444P::ConvertFrom(Utils_YUV420P*, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  MOZ_ASSERT(aSrcBuffer, "Convert color from a null buffer.");
+  MOZ_ASSERT(aSrcLayout, "Convert color from a null layout.");
+  MOZ_ASSERT(aDstBuffer, "Convert color to a null buffer.");
+
+  UniquePtr<ImagePixelLayout> layout =
+    CreateDefaultLayout((*aSrcLayout)[0].mWidth,
+                        (*aSrcLayout)[0].mHeight,
+                        (*aSrcLayout)[0].mWidth);
+
+  MOZ_ASSERT(layout, "Cannot create a ImagePixelLayout of YUV444P");
+
+  const nsTArray<ChannelPixelLayout>& channels = *layout;
+
+  const nsTArray<ChannelPixelLayout>& srcChannels = *aSrcLayout;
+
+  int rv = I420ToI444(aSrcBuffer + srcChannels[0].mOffset, srcChannels[0].mStride,
+                      aSrcBuffer + srcChannels[1].mOffset, srcChannels[1].mStride,
+                      aSrcBuffer + srcChannels[2].mOffset, srcChannels[2].mStride,
+                      aDstBuffer + channels[0].mOffset, channels[0].mStride,
+                      aDstBuffer + channels[1].mOffset, channels[1].mStride,
+                      aDstBuffer + channels[2].mOffset, channels[2].mStride,
+                      channels[0].mWidth, channels[0].mHeight);
+
+  if (NS_WARN_IF(rv != 0)) {
+    return nullptr;
+  }
+
+  return layout;
+}
+
+// TODO: optimize me.
+UniquePtr<ImagePixelLayout>
+Utils_YUV444P::ConvertFrom(Utils_YUV420SP_NV12* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420P, this);
+}
+
+// TODO: optimize me.
+UniquePtr<ImagePixelLayout>
+Utils_YUV444P::ConvertFrom(Utils_YUV420SP_NV21* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420P, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV444P::ConvertFrom(Utils_HSV* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV444P::ConvertFrom(Utils_Lab* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV444P::ConvertFrom(Utils_Depth* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+bool
+Utils_YUV444P::CanConvertFrom(ImageBitmapFormat aSrcFormat)
+{
+  if (aSrcFormat == ImageBitmapFormat::GRAY8 ||
+      aSrcFormat == ImageBitmapFormat::DEPTH) {
+    return false;
+  }
+
+  return true;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV444P::CreateDefaultLayout(uint32_t aWidth, uint32_t aHeight, uint32_t aStride)
+{
+  UniquePtr<ImagePixelLayout> layout(new ImagePixelLayout(mChannels));
+
+  // set mChannels
+  ChannelPixelLayout* ychannel = layout->AppendElement();
+  ChannelPixelLayout* uchannel = layout->AppendElement();
+  ChannelPixelLayout* vchannel = layout->AppendElement();
+  ychannel->mOffset = 0;
+  ychannel->mWidth  = aWidth;
+  ychannel->mHeight = aHeight;
+  ychannel->mDataType = ChannelPixelLayoutDataType::Uint8;
+  ychannel->mStride = aStride;
+  ychannel->mSkip   = 0; // aYSkip;
+
+  uchannel->mOffset = ychannel->mOffset + ychannel->mStride * ychannel->mHeight;
+  uchannel->mWidth  = aWidth;
+  uchannel->mHeight = aHeight;
+  uchannel->mDataType = ChannelPixelLayoutDataType::Uint8;
+  uchannel->mStride = aStride;
+  uchannel->mSkip   = 0; // aUSkip;
+
+  vchannel->mOffset = uchannel->mOffset + uchannel->mStride * uchannel->mHeight;
+  vchannel->mWidth  = aWidth;
+  vchannel->mHeight = aHeight;
+  vchannel->mDataType = ChannelPixelLayoutDataType::Uint8;
+  vchannel->mStride = aStride;
+  vchannel->mSkip   = 0; // aVSkip;
+
+  return layout;
+}
+
+/*
+ * class Utils_YUV422P.
+ */
+/* static */Utils_YUV422P&
+Utils_YUV422P::GetInstance()
+{
+  static Utils_YUV422P instance;
+  return instance;
+}
+
+Utils_YUV422P::Utils_YUV422P()
+: Utils(3, ChannelPixelLayoutDataType::Uint8)
+{
+}
+
+uint32_t
+Utils_YUV422P::NeededBufferSize(uint32_t aWidth, uint32_t aHeight)
+{
+  return aWidth * aHeight * mBytesPerPixelValue +
+         2 * ((aWidth + 1) / 2) * aHeight * mBytesPerPixelValue;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV422P::ConvertTo(Utils* aDstFormat, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return aDstFormat->ConvertFrom(this, aSrcBuffer, aSrcLayout, aDstBuffer);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV422P::ConvertFrom(Utils_RGBA32* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToYUVImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV422P, &RGBA32ToYUV422P);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV422P::ConvertFrom(Utils_BGRA32* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToYUVImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV422P, &libyuv::ARGBToI422);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV422P::ConvertFrom(Utils_RGB24* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToYUVImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV422P, &RGB24ToYUV422P);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV422P::ConvertFrom(Utils_BGR24* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToYUVImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV422P, &BGR24ToYUV422P);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV422P::ConvertFrom(Utils_Gray8* aSrcFormat, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+// TODO: optimize me.
+UniquePtr<ImagePixelLayout>
+Utils_YUV422P::ConvertFrom(Utils_YUV444P* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420P, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV422P::ConvertFrom(Utils_YUV422P* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return PureCopy(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV422P);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV422P::ConvertFrom(Utils_YUV420P*, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  MOZ_ASSERT(aSrcBuffer, "Convert color from a null buffer.");
+  MOZ_ASSERT(aSrcLayout, "Convert color from a null layout.");
+  MOZ_ASSERT(aDstBuffer, "Convert color to a null buffer.");
+
+  UniquePtr<ImagePixelLayout> layout =
+    CreateDefaultLayout((*aSrcLayout)[0].mWidth,
+                        (*aSrcLayout)[0].mHeight,
+                        (*aSrcLayout)[0].mWidth);
+
+  MOZ_ASSERT(layout, "Cannot create a ImagePixelLayout of YUV422P");
+
+  const nsTArray<ChannelPixelLayout>& channels = *layout;
+
+  const nsTArray<ChannelPixelLayout>& srcChannels = *aSrcLayout;
+
+  libyuv::I420ToI422(aSrcBuffer + srcChannels[0].mOffset, srcChannels[0].mStride,
+                     aSrcBuffer + srcChannels[1].mOffset, srcChannels[1].mStride,
+                     aSrcBuffer + srcChannels[2].mOffset, srcChannels[2].mStride,
+                     aDstBuffer + channels[0].mOffset, channels[0].mStride,
+                     aDstBuffer + channels[1].mOffset, channels[1].mStride,
+                     aDstBuffer + channels[2].mOffset, channels[2].mStride,
+                     channels[0].mWidth, channels[0].mHeight);
+
+  return layout;
+}
+
+// TODO: optimize me.
+UniquePtr<ImagePixelLayout>
+Utils_YUV422P::ConvertFrom(Utils_YUV420SP_NV12* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420P, this);
+}
+
+// TODO: optimize me.
+UniquePtr<ImagePixelLayout>
+Utils_YUV422P::ConvertFrom(Utils_YUV420SP_NV21* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420P, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV422P::ConvertFrom(Utils_HSV* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV422P::ConvertFrom(Utils_Lab* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV422P::ConvertFrom(Utils_Depth* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+bool
+Utils_YUV422P::CanConvertFrom(ImageBitmapFormat aSrcFormat)
+{
+  if (aSrcFormat == ImageBitmapFormat::GRAY8 ||
+      aSrcFormat == ImageBitmapFormat::DEPTH) {
+    return false;
+  }
+
+  return true;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV422P::CreateDefaultLayout(uint32_t aWidth, uint32_t aHeight, uint32_t aStride)
+{
+  UniquePtr<ImagePixelLayout> layout(new ImagePixelLayout(mChannels));
+
+  // set mChannels
+  ChannelPixelLayout* ychannel = layout->AppendElement();
+  ChannelPixelLayout* uchannel = layout->AppendElement();
+  ChannelPixelLayout* vchannel = layout->AppendElement();
+  ychannel->mOffset = 0;
+  ychannel->mWidth  = aWidth;
+  ychannel->mHeight = aHeight;
+  ychannel->mDataType = ChannelPixelLayoutDataType::Uint8;
+  ychannel->mStride = aStride;
+  ychannel->mSkip   = 0; // aYSkip;
+
+  uchannel->mOffset = ychannel->mOffset + ychannel->mStride * ychannel->mHeight;
+  uchannel->mWidth  = (aWidth + 1) / 2;
+  uchannel->mHeight = aHeight;
+  uchannel->mDataType = ChannelPixelLayoutDataType::Uint8;
+  uchannel->mStride = (aStride + 1) / 2;
+  uchannel->mSkip   = 0; // aUSkip;
+
+  vchannel->mOffset = uchannel->mOffset + uchannel->mStride * uchannel->mHeight;
+  vchannel->mWidth  = (aWidth + 1) / 2;
+  vchannel->mHeight = aHeight;
+  vchannel->mDataType = ChannelPixelLayoutDataType::Uint8;
+  vchannel->mStride = (aStride + 1) / 2;
+  vchannel->mSkip   = 0; // aVSkip;
+
+  return layout;
+}
+
+/*
+ * Utils_YUV420P.
+ */
+/* static */Utils_YUV420P&
+Utils_YUV420P::GetInstance()
+{
+  static Utils_YUV420P instance;
+  return instance;
+}
+
+Utils_YUV420P::Utils_YUV420P()
+: Utils(3, ChannelPixelLayoutDataType::Uint8)
+{
+}
+
+uint32_t
+Utils_YUV420P::NeededBufferSize(uint32_t aWidth, uint32_t aHeight)
+{
+  return aWidth * aHeight * mBytesPerPixelValue +
+         2 * ((aWidth + 1) / 2) * ((aHeight + 1) / 2) * mBytesPerPixelValue;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420P::ConvertTo(Utils* aDstFormat, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return aDstFormat->ConvertFrom(this, aSrcBuffer, aSrcLayout, aDstBuffer);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420P::ConvertFrom(Utils_RGBA32* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToYUVImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420P, &libyuv::ABGRToI420);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420P::ConvertFrom(Utils_BGRA32* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToYUVImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420P, &libyuv::ARGBToI420);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420P::ConvertFrom(Utils_RGB24* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToYUVImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420P, &RGB24ToYUV420P);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420P::ConvertFrom(Utils_BGR24* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToYUVImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420P, &BGR24ToYUV420P);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420P::ConvertFrom(Utils_Gray8* aSrcFormat, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420P::ConvertFrom(Utils_YUV444P*, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  MOZ_ASSERT(aSrcBuffer, "Convert color from a null buffer.");
+  MOZ_ASSERT(aSrcLayout, "Convert color from a null layout.");
+  MOZ_ASSERT(aDstBuffer, "Convert color to a null buffer.");
+
+  UniquePtr<ImagePixelLayout> layout =
+    CreateDefaultLayout((*aSrcLayout)[0].mWidth,
+                        (*aSrcLayout)[0].mHeight,
+                        (*aSrcLayout)[0].mWidth);
+
+  MOZ_ASSERT(layout, "Cannot create a ImagePixelLayout of YUV420P");
+
+  const nsTArray<ChannelPixelLayout>& channels = *layout;
+
+  const nsTArray<ChannelPixelLayout>& srcChannels = *aSrcLayout;
+
+  libyuv::I444ToI420(aSrcBuffer + srcChannels[0].mOffset, srcChannels[0].mStride,
+                     aSrcBuffer + srcChannels[1].mOffset, srcChannels[1].mStride,
+                     aSrcBuffer + srcChannels[2].mOffset, srcChannels[2].mStride,
+                     aDstBuffer + channels[0].mOffset, channels[0].mStride,
+                     aDstBuffer + channels[1].mOffset, channels[1].mStride,
+                     aDstBuffer + channels[2].mOffset, channels[2].mStride,
+                     channels[0].mWidth, channels[0].mHeight);
+
+  return layout;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420P::ConvertFrom(Utils_YUV422P*, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  MOZ_ASSERT(aSrcBuffer, "Convert color from a null buffer.");
+  MOZ_ASSERT(aSrcLayout, "Convert color from a null layout.");
+  MOZ_ASSERT(aDstBuffer, "Convert color to a null buffer.");
+
+  UniquePtr<ImagePixelLayout> layout =
+    CreateDefaultLayout((*aSrcLayout)[0].mWidth,
+                        (*aSrcLayout)[0].mHeight,
+                        (*aSrcLayout)[0].mWidth);
+
+  MOZ_ASSERT(layout, "Cannot create a ImagePixelLayout of YUV420P");
+
+  const nsTArray<ChannelPixelLayout>& channels = *layout;
+
+  const nsTArray<ChannelPixelLayout>& srcChannels = *aSrcLayout;
+
+  libyuv::I422ToI420(aSrcBuffer + srcChannels[0].mOffset, srcChannels[0].mStride,
+                     aSrcBuffer + srcChannels[1].mOffset, srcChannels[1].mStride,
+                     aSrcBuffer + srcChannels[2].mOffset, srcChannels[2].mStride,
+                     aDstBuffer + channels[0].mOffset, channels[0].mStride,
+                     aDstBuffer + channels[1].mOffset, channels[1].mStride,
+                     aDstBuffer + channels[2].mOffset, channels[2].mStride,
+                     channels[0].mWidth, channels[0].mHeight);
+
+  return layout;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420P::ConvertFrom(Utils_YUV420P* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return PureCopy(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420P);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420P::ConvertFrom(Utils_YUV420SP_NV12*, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  MOZ_ASSERT(aSrcBuffer, "Convert color from a null buffer.");
+  MOZ_ASSERT(aSrcLayout, "Convert color from a null layout.");
+  MOZ_ASSERT(aDstBuffer, "Convert color to a null buffer.");
+
+  UniquePtr<ImagePixelLayout> layout =
+    CreateDefaultLayout((*aSrcLayout)[0].mWidth,
+                        (*aSrcLayout)[0].mHeight,
+                        (*aSrcLayout)[0].mWidth);
+
+  MOZ_ASSERT(layout, "Cannot create a ImagePixelLayout of YUV420P");
+
+  const nsTArray<ChannelPixelLayout>& channels = *layout;
+
+  const nsTArray<ChannelPixelLayout>& srcChannels = *aSrcLayout;
+
+  libyuv::NV12ToI420(aSrcBuffer + srcChannels[0].mOffset, srcChannels[0].mStride,
+                     aSrcBuffer + srcChannels[1].mOffset, srcChannels[1].mStride,
+                     aDstBuffer + channels[0].mOffset, channels[0].mStride,
+                     aDstBuffer + channels[1].mOffset, channels[1].mStride,
+                     aDstBuffer + channels[2].mOffset, channels[2].mStride,
+                     channels[0].mWidth, channels[0].mHeight);
+
+  return layout;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420P::ConvertFrom(Utils_YUV420SP_NV21*, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  MOZ_ASSERT(aSrcBuffer, "Convert color from a null buffer.");
+  MOZ_ASSERT(aSrcLayout, "Convert color from a null layout.");
+  MOZ_ASSERT(aDstBuffer, "Convert color to a null buffer.");
+
+  UniquePtr<ImagePixelLayout> layout =
+    CreateDefaultLayout((*aSrcLayout)[0].mWidth,
+                        (*aSrcLayout)[0].mHeight,
+                        (*aSrcLayout)[0].mWidth);
+
+  MOZ_ASSERT(layout, "Cannot create a ImagePixelLayout of YUV420P");
+
+  const nsTArray<ChannelPixelLayout>& channels = *layout;
+
+  const nsTArray<ChannelPixelLayout>& srcChannels = *aSrcLayout;
+
+  libyuv::NV21ToI420(aSrcBuffer + srcChannels[0].mOffset, srcChannels[0].mStride,
+                     aSrcBuffer + srcChannels[1].mOffset, srcChannels[1].mStride,
+                     aDstBuffer + channels[0].mOffset, channels[0].mStride,
+                     aDstBuffer + channels[1].mOffset, channels[1].mStride,
+                     aDstBuffer + channels[2].mOffset, channels[2].mStride,
+                     channels[0].mWidth, channels[0].mHeight);
+
+  return layout;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420P::ConvertFrom(Utils_HSV* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420P::ConvertFrom(Utils_Lab* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420P::ConvertFrom(Utils_Depth* aSrcUtils, const uint8_t* aSrcBuffer,
+                           const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+bool
+Utils_YUV420P::CanConvertFrom(ImageBitmapFormat aSrcFormat)
+{
+  if (aSrcFormat == ImageBitmapFormat::GRAY8 ||
+      aSrcFormat == ImageBitmapFormat::DEPTH) {
+    return false;
+  }
+
+  return true;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420P::CreateDefaultLayout(uint32_t aWidth, uint32_t aHeight, uint32_t aStride)
+{
+  UniquePtr<ImagePixelLayout> layout(new ImagePixelLayout(mChannels));
+
+  // set mChannels
+  ChannelPixelLayout* ychannel = layout->AppendElement();
+  ChannelPixelLayout* uchannel = layout->AppendElement();
+  ChannelPixelLayout* vchannel = layout->AppendElement();
+  ychannel->mOffset = 0;
+  ychannel->mWidth  = aWidth;
+  ychannel->mHeight = aHeight;
+  ychannel->mDataType = ChannelPixelLayoutDataType::Uint8;
+  ychannel->mStride = aStride;
+  ychannel->mSkip   = 0; // aYSkip;
+
+  uchannel->mOffset = ychannel->mOffset + ychannel->mStride * ychannel->mHeight;
+  uchannel->mWidth  = (aWidth + 1) / 2;
+  uchannel->mHeight = (aHeight + 1) / 2;
+  uchannel->mDataType = ChannelPixelLayoutDataType::Uint8;
+  uchannel->mStride = (aStride + 1) / 2;
+  uchannel->mSkip   = 0; // aUSkip;
+
+  vchannel->mOffset = uchannel->mOffset + uchannel->mStride * uchannel->mHeight;
+  vchannel->mWidth  = (aWidth + 1) / 2;
+  vchannel->mHeight = (aHeight + 1) / 2;
+  vchannel->mDataType = ChannelPixelLayoutDataType::Uint8;
+  vchannel->mStride = (aStride + 1) / 2;
+  vchannel->mSkip   = 0; // aVSkip;
+
+  return layout;
+}
+
+/*
+ * class Utils_YUV420SP_NV12.
+ */
+/* static */Utils_YUV420SP_NV12&
+Utils_YUV420SP_NV12::GetInstance()
+{
+  static Utils_YUV420SP_NV12 instance;
+  return instance;
+}
+
+Utils_YUV420SP_NV12::Utils_YUV420SP_NV12()
+: Utils(3, ChannelPixelLayoutDataType::Uint8)
+{
+}
+
+uint32_t
+Utils_YUV420SP_NV12::NeededBufferSize(uint32_t aWidth, uint32_t aHeight)
+{
+  return aWidth * aHeight * mBytesPerPixelValue +
+         2 * ((aWidth + 1) / 2) * ((aHeight + 1) / 2) * mBytesPerPixelValue;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV12::ConvertTo(Utils* aDstFormat, const uint8_t* aSrcBuffer,
+                               const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return aDstFormat->ConvertFrom(this, aSrcBuffer, aSrcLayout, aDstBuffer);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV12::ConvertFrom(Utils_RGBA32* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToNVImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420SP_NV12, &RGBA32ToNV12);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV12::ConvertFrom(Utils_BGRA32* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToNVImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420SP_NV12, &libyuv::ARGBToNV12);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV12::ConvertFrom(Utils_RGB24* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToNVImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420SP_NV12, &RGB24ToNV12);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV12::ConvertFrom(Utils_BGR24* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToNVImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420SP_NV12, &BGR24ToNV12);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV12::ConvertFrom(Utils_Gray8* aSrcFormat, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+// TODO: optimize me.
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV12::ConvertFrom(Utils_YUV444P* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420P, this);
+}
+
+// TODO: optimize me.
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV12::ConvertFrom(Utils_YUV422P* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420P, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV12::ConvertFrom(Utils_YUV420P*, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  MOZ_ASSERT(aSrcBuffer, "Convert color from a null buffer.");
+  MOZ_ASSERT(aSrcLayout, "Convert color from a null layout.");
+  MOZ_ASSERT(aDstBuffer, "Convert color to a null buffer.");
+
+  UniquePtr<ImagePixelLayout> layout =
+    CreateDefaultLayout((*aSrcLayout)[0].mWidth,
+                        (*aSrcLayout)[0].mHeight,
+                        (*aSrcLayout)[0].mWidth);
+
+  MOZ_ASSERT(layout, "Cannot create a ImagePixelLayout of YUV420SP_NV12");
+
+  const nsTArray<ChannelPixelLayout>& channels = *layout;
+
+  const nsTArray<ChannelPixelLayout>& srcChannels = *aSrcLayout;
+
+  libyuv::I420ToNV12(aSrcBuffer + srcChannels[0].mOffset, srcChannels[0].mStride,
+                     aSrcBuffer + srcChannels[1].mOffset, srcChannels[1].mStride,
+                     aSrcBuffer + srcChannels[2].mOffset, srcChannels[2].mStride,
+                     aDstBuffer + channels[0].mOffset, channels[0].mStride,
+                     aDstBuffer + channels[1].mOffset, channels[1].mStride,
+                     channels[0].mWidth, channels[0].mHeight);
+
+  return layout;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV12::ConvertFrom(Utils_YUV420SP_NV12* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return PureCopy(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420SP_NV12);
+}
+
+// TODO: optimize me.
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV12::ConvertFrom(Utils_YUV420SP_NV21* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420P, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV12::ConvertFrom(Utils_HSV* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV12::ConvertFrom(Utils_Lab* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV12::ConvertFrom(Utils_Depth* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+bool
+Utils_YUV420SP_NV12::CanConvertFrom(ImageBitmapFormat aSrcFormat)
+{
+  if (aSrcFormat == ImageBitmapFormat::GRAY8 ||
+      aSrcFormat == ImageBitmapFormat::DEPTH) {
+    return false;
+  }
+
+  return true;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV12::CreateDefaultLayout(uint32_t aWidth, uint32_t aHeight, uint32_t aStride)
+{
+  UniquePtr<ImagePixelLayout> layout(new ImagePixelLayout(mChannels));
+
+  // set mChannels
+  ChannelPixelLayout* ychannel = layout->AppendElement();
+  ChannelPixelLayout* uchannel = layout->AppendElement();
+  ChannelPixelLayout* vchannel = layout->AppendElement();
+  ychannel->mOffset = 0;
+  ychannel->mWidth  = aWidth;
+  ychannel->mHeight = aHeight;
+  ychannel->mDataType = ChannelPixelLayoutDataType::Uint8;
+  ychannel->mStride = aStride;
+  ychannel->mSkip   = 0; // aYSkip;
+
+  uchannel->mOffset = ychannel->mOffset + ychannel->mStride * ychannel->mHeight;
+  uchannel->mWidth  = (aWidth + 1) / 2;
+  uchannel->mHeight = (aHeight + 1) / 2;
+  uchannel->mDataType = ChannelPixelLayoutDataType::Uint8;
+  uchannel->mStride = uchannel->mWidth * 2;
+  uchannel->mSkip   = 1; // aUSkip;
+
+  vchannel->mOffset = ychannel->mOffset + ychannel->mStride * ychannel->mHeight + 1;
+  vchannel->mWidth  = (aWidth + 1) / 2;
+  vchannel->mHeight = (aHeight + 1) / 2;
+  vchannel->mDataType = ChannelPixelLayoutDataType::Uint8;
+  vchannel->mStride = vchannel->mWidth * 2;
+  vchannel->mSkip   = 1; // aVSkip;
+
+  return layout;
+}
+
+/*
+ * class Utils_YUV420SP_NV21.
+ */
+/* static */Utils_YUV420SP_NV21&
+Utils_YUV420SP_NV21::GetInstance()
+{
+  static Utils_YUV420SP_NV21 instance;
+  return instance;
+}
+
+Utils_YUV420SP_NV21::Utils_YUV420SP_NV21()
+: Utils(3, ChannelPixelLayoutDataType::Uint8)
+{
+}
+
+uint32_t
+Utils_YUV420SP_NV21::NeededBufferSize(uint32_t aWidth, uint32_t aHeight)
+{
+  return aWidth * aHeight * mBytesPerPixelValue +
+         2 * ((aWidth + 1) / 2) * ((aHeight + 1) / 2) * mBytesPerPixelValue;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV21::ConvertTo(Utils* aDstFormat, const uint8_t* aSrcBuffer,
+                               const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return aDstFormat->ConvertFrom(this, aSrcBuffer, aSrcLayout, aDstBuffer);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV21::ConvertFrom(Utils_RGBA32* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToNVImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420SP_NV21, &RGBA32ToNV21);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV21::ConvertFrom(Utils_BGRA32* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToNVImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420SP_NV21, &libyuv::ARGBToNV21);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV21::ConvertFrom(Utils_RGB24* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToNVImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420SP_NV21, &RGB24ToNV21);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV21::ConvertFrom(Utils_BGR24* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToNVImg(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420SP_NV21, &BGR24ToNV21);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV21::ConvertFrom(Utils_Gray8* aSrcFormat, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+// TODO: optimize me.
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV21::ConvertFrom(Utils_YUV444P* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420P, this);
+}
+
+// TODO: optimize me.
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV21::ConvertFrom(Utils_YUV422P* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420P, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV21::ConvertFrom(Utils_YUV420P*, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  MOZ_ASSERT(aSrcBuffer, "Convert color from a null buffer.");
+  MOZ_ASSERT(aSrcLayout, "Convert color from a null layout.");
+  MOZ_ASSERT(aDstBuffer, "Convert color to a null buffer.");
+
+  UniquePtr<ImagePixelLayout> layout =
+    CreateDefaultLayout((*aSrcLayout)[0].mWidth,
+                        (*aSrcLayout)[0].mHeight,
+                        (*aSrcLayout)[0].mWidth);
+
+  MOZ_ASSERT(layout, "Cannot create a ImagePixelLayout of YUV420SP_NV21");
+
+  const nsTArray<ChannelPixelLayout>& channels = *layout;
+
+  const nsTArray<ChannelPixelLayout>& srcChannels = *aSrcLayout;
+
+  libyuv::I420ToNV21(aSrcBuffer + srcChannels[0].mOffset, srcChannels[0].mStride,
+                     aSrcBuffer + srcChannels[1].mOffset, srcChannels[1].mStride,
+                     aSrcBuffer + srcChannels[2].mOffset, srcChannels[2].mStride,
+                     aDstBuffer + channels[0].mOffset, channels[0].mStride,
+                     aDstBuffer + channels[1].mOffset, channels[1].mStride,
+                     channels[0].mWidth, channels[0].mHeight);
+
+  return layout;
+}
+
+// TODO: optimize me.
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV21::ConvertFrom(Utils_YUV420SP_NV12* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420P, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV21::ConvertFrom(Utils_YUV420SP_NV21* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return PureCopy(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::YUV420SP_NV21);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV21::ConvertFrom(Utils_HSV* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV21::ConvertFrom(Utils_Lab* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV21::ConvertFrom(Utils_Depth* aSrcUtils, const uint8_t* aSrcBuffer,
+                                 const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+bool
+Utils_YUV420SP_NV21::CanConvertFrom(ImageBitmapFormat aSrcFormat)
+{
+  if (aSrcFormat == ImageBitmapFormat::GRAY8 ||
+      aSrcFormat == ImageBitmapFormat::DEPTH) {
+    return false;
+  }
+
+  return true;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_YUV420SP_NV21::CreateDefaultLayout(uint32_t aWidth, uint32_t aHeight, uint32_t aStride)
+{
+  UniquePtr<ImagePixelLayout> layout(new ImagePixelLayout(mChannels));
+
+  // set mChannels
+  ChannelPixelLayout* ychannel = layout->AppendElement();
+  ChannelPixelLayout* vchannel = layout->AppendElement(); // v is the 2nd channel.
+  ChannelPixelLayout* uchannel = layout->AppendElement(); // u is the 3rd channel.
+  ychannel->mOffset = 0;
+  ychannel->mWidth  = aWidth;
+  ychannel->mHeight = aHeight;
+  ychannel->mDataType = ChannelPixelLayoutDataType::Uint8;
+  ychannel->mStride = aStride;
+  ychannel->mSkip   = 0; // aYSkip;
+
+  vchannel->mOffset = ychannel->mOffset + ychannel->mStride * ychannel->mHeight;
+  vchannel->mWidth  = (aWidth + 1) / 2;
+  vchannel->mHeight = (aHeight + 1) / 2;
+  vchannel->mDataType = ChannelPixelLayoutDataType::Uint8;
+  vchannel->mStride = vchannel->mWidth * 2;
+  vchannel->mSkip   = 1; // aVSkip;
+
+  uchannel->mOffset = ychannel->mOffset + ychannel->mStride * ychannel->mHeight + 1;
+  uchannel->mWidth  = (aWidth + 1) / 2;
+  uchannel->mHeight = (aHeight + 1) / 2;
+  uchannel->mDataType = ChannelPixelLayoutDataType::Uint8;
+  uchannel->mStride = uchannel->mWidth * 2;
+  uchannel->mSkip   = 1; // aUSkip;
+
+  return layout;
+}
+
+/*
+ * Utils_HSV.
+ */
+/* static */Utils_HSV&
+Utils_HSV::GetInstance()
+{
+  static Utils_HSV instance;
+  return instance;
+}
+
+Utils_HSV::Utils_HSV()
+: Utils(3, ChannelPixelLayoutDataType::Float32)
+{
+}
+
+uint32_t
+Utils_HSV::NeededBufferSize(uint32_t aWidth, uint32_t aHeight)
+{
+  return aWidth * aHeight * (uint32_t)mChannels * mBytesPerPixelValue;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_HSV::ConvertTo(Utils* aDstFormat, const uint8_t* aSrcBuffer,
+                     const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return aDstFormat->ConvertFrom(this, aSrcBuffer, aSrcLayout, aDstBuffer);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_HSV::ConvertFrom(Utils_RGBA32* aSrcFormat, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, float>(aSrcFormat, aSrcBuffer, aSrcLayout, (float*)aDstBuffer, ImageBitmapFormat::HSV, 3, &RGBA32ToHSV);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_HSV::ConvertFrom(Utils_BGRA32* aSrcFormat, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, float>(aSrcFormat, aSrcBuffer, aSrcLayout, (float*)aDstBuffer, ImageBitmapFormat::HSV, 3, &BGRA32ToHSV);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_HSV::ConvertFrom(Utils_RGB24* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, float>(aSrcUtils, aSrcBuffer, aSrcLayout, (float*)aDstBuffer, ImageBitmapFormat::HSV, 3, &RGB24ToHSV);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_HSV::ConvertFrom(Utils_BGR24* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, float>(aSrcUtils, aSrcBuffer, aSrcLayout, (float*)aDstBuffer, ImageBitmapFormat::HSV, 3, &BGR24ToHSV);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_HSV::ConvertFrom(Utils_Gray8* aSrcFormat, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_HSV::ConvertFrom(Utils_YUV444P* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_HSV::ConvertFrom(Utils_YUV422P* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_HSV::ConvertFrom(Utils_YUV420P* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_HSV::ConvertFrom(Utils_YUV420SP_NV12* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_HSV::ConvertFrom(Utils_YUV420SP_NV21* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_HSV::ConvertFrom(Utils_HSV* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return PureCopy(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::HSV);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_HSV::ConvertFrom(Utils_Lab* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_HSV::ConvertFrom(Utils_Depth* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+bool
+Utils_HSV::CanConvertFrom(ImageBitmapFormat aSrcFormat)
+{
+  if (aSrcFormat == ImageBitmapFormat::GRAY8 ||
+      aSrcFormat == ImageBitmapFormat::DEPTH) {
+    return false;
+  }
+
+  return true;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_HSV::CreateDefaultLayout(uint32_t aWidth, uint32_t aHeight, uint32_t aStride)
+{
+  return CreateDefaultLayoutForSimpleImage(aWidth, aHeight, aStride, mChannels, mBytesPerPixelValue, mDataType);
+}
+
+/*
+ * Utils_Lab.
+ */
+/* static */Utils_Lab&
+Utils_Lab::GetInstance()
+{
+  static Utils_Lab instance;
+  return instance;
+}
+
+Utils_Lab::Utils_Lab()
+: Utils(3, ChannelPixelLayoutDataType::Float32)
+{
+}
+
+uint32_t
+Utils_Lab::NeededBufferSize(uint32_t aWidth, uint32_t aHeight)
+{
+  return aWidth * aHeight * (uint32_t)mChannels * mBytesPerPixelValue;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Lab::ConvertTo(Utils* aDstFormat, const uint8_t* aSrcBuffer,
+                     const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return aDstFormat->ConvertFrom(this, aSrcBuffer, aSrcLayout, aDstBuffer);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Lab::ConvertFrom(Utils_RGBA32* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, float>(aSrcUtils, aSrcBuffer, aSrcLayout, (float*)aDstBuffer, ImageBitmapFormat::Lab, 3, &RGBA32ToLab);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Lab::ConvertFrom(Utils_BGRA32* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, float>(aSrcUtils, aSrcBuffer, aSrcLayout, (float*)aDstBuffer, ImageBitmapFormat::Lab, 3, &BGRA32ToLab);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Lab::ConvertFrom(Utils_RGB24* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, float>(aSrcUtils, aSrcBuffer, aSrcLayout, (float*)aDstBuffer, ImageBitmapFormat::Lab, 3, &RGB24ToLab);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Lab::ConvertFrom(Utils_BGR24* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return CvtSimpleImgToSimpleImg<uint8_t, float>(aSrcUtils, aSrcBuffer, aSrcLayout, (float*)aDstBuffer, ImageBitmapFormat::Lab, 3, &BGR24ToLab);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Lab::ConvertFrom(Utils_Gray8* aSrcFormat, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Lab::ConvertFrom(Utils_YUV444P* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Lab::ConvertFrom(Utils_YUV422P* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Lab::ConvertFrom(Utils_YUV420P* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Lab::ConvertFrom(Utils_YUV420SP_NV12* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Lab::ConvertFrom(Utils_YUV420SP_NV21* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Lab::ConvertFrom(Utils_HSV* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return TwoPassConversion(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::RGB24, this);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Lab::ConvertFrom(Utils_Lab* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return PureCopy(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::Lab);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Lab::ConvertFrom(Utils_Depth* aSrcUtils, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+bool
+Utils_Lab::CanConvertFrom(ImageBitmapFormat aSrcFormat)
+{
+  if (aSrcFormat == ImageBitmapFormat::GRAY8 ||
+      aSrcFormat == ImageBitmapFormat::DEPTH) {
+    return false;
+  }
+
+  return true;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Lab::CreateDefaultLayout(uint32_t aWidth, uint32_t aHeight, uint32_t aStride)
+{
+  return CreateDefaultLayoutForSimpleImage(aWidth, aHeight, aStride, mChannels, mBytesPerPixelValue, mDataType);
+}
+
+/*
+ * Utils_Depth.
+ */
+/* static */Utils_Depth&
+Utils_Depth::GetInstance()
+{
+  static Utils_Depth instance;
+  return instance;
+}
+
+Utils_Depth::Utils_Depth()
+: Utils(1, ChannelPixelLayoutDataType::Uint16)
+{
+}
+
+uint32_t
+Utils_Depth::NeededBufferSize(uint32_t aWidth, uint32_t aHeight)
+{
+  return aWidth * aHeight * (uint32_t)mChannels * mBytesPerPixelValue;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Depth::ConvertTo(Utils* aDstFormat, const uint8_t* aSrcBuffer,
+                       const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return aDstFormat->ConvertFrom(this, aSrcBuffer, aSrcLayout, aDstBuffer);
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Depth::ConvertFrom(Utils_RGBA32* aSrcFormat, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Depth::ConvertFrom(Utils_BGRA32* aSrcFormat, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Depth::ConvertFrom(Utils_RGB24* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Depth::ConvertFrom(Utils_BGR24* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Depth::ConvertFrom(Utils_Gray8* aSrcFormat, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Depth::ConvertFrom(Utils_YUV444P* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Depth::ConvertFrom(Utils_YUV422P* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Depth::ConvertFrom(Utils_YUV420P* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Depth::ConvertFrom(Utils_YUV420SP_NV12* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Depth::ConvertFrom(Utils_YUV420SP_NV21* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Depth::ConvertFrom(Utils_HSV* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Depth::ConvertFrom(Utils_Lab* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return nullptr;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Depth::ConvertFrom(Utils_Depth* aSrcUtils, const uint8_t* aSrcBuffer,
+                         const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer)
+{
+  return PureCopy(aSrcUtils, aSrcBuffer, aSrcLayout, aDstBuffer, ImageBitmapFormat::DEPTH);
+}
+
+bool
+Utils_Depth::CanConvertFrom(ImageBitmapFormat aSrcFormat)
+{
+  if (aSrcFormat == ImageBitmapFormat::DEPTH ) {
+    return true;
+  }
+
+  return false;
+}
+
+UniquePtr<ImagePixelLayout>
+Utils_Depth::CreateDefaultLayout(uint32_t aWidth, uint32_t aHeight, uint32_t aStride)
+{
+  return CreateDefaultLayoutForSimpleImage(aWidth, aHeight, aStride, mChannels, mBytesPerPixelValue, mDataType);
+}
+
+} // namespace imagebitmapformat
+
+/*
+ * Global functions.
+ */
+
+using namespace mozilla::dom::imagebitmapformat;
+
+UniquePtr<ImagePixelLayout>
+CreateDefaultPixelLayout(ImageBitmapFormat aFormat, uint32_t aWidth,
+                         uint32_t aHeight, uint32_t aStride)
+{
+  UtilsUniquePtr format = Utils::GetUtils(aFormat);
+  MOZ_ASSERT(format, "Cannot get a valid ImageBitmapFormatUtils instance.");
+
+  return format->CreateDefaultLayout(aWidth, aHeight, aStride);
+}
+
+UniquePtr<ImagePixelLayout>
+CreatePixelLayoutFromPlanarYCbCrData(const layers::PlanarYCbCrData* aData)
+{
+  if (!aData) {
+    // something wrong
+    return nullptr;
+  }
+
+  UniquePtr<ImagePixelLayout> layout(new ImagePixelLayout(3));
+
+  ChannelPixelLayout* ychannel = layout->AppendElement();
+  ChannelPixelLayout* uchannel = layout->AppendElement();
+  ChannelPixelLayout* vchannel = layout->AppendElement();
+
+  ychannel->mOffset = 0;
+
+  if (aData->mCrChannel - aData->mCbChannel > 0) {
+    uchannel->mOffset = ychannel->mOffset + (aData->mCbChannel - aData->mYChannel);
+    vchannel->mOffset = uchannel->mOffset + (aData->mCrChannel - aData->mCbChannel);
+  } else {
+    uchannel->mOffset = ychannel->mOffset + (aData->mCrChannel - aData->mYChannel);
+    vchannel->mOffset = uchannel->mOffset + (aData->mCbChannel - aData->mCrChannel);
+  }
+
+  ychannel->mWidth = aData->mYSize.width;
+  ychannel->mHeight = aData->mYSize.height;
+  ychannel->mDataType = ChannelPixelLayoutDataType::Uint8;
+  ychannel->mStride = aData->mYStride;
+  ychannel->mSkip = aData->mYSkip;
+
+  uchannel->mWidth = aData->mCbCrSize.width;
+  uchannel->mHeight = aData->mCbCrSize.height;
+  uchannel->mDataType = ChannelPixelLayoutDataType::Uint8;
+  uchannel->mStride = aData->mCbCrStride;
+  uchannel->mSkip = aData->mCbSkip;
+
+  vchannel->mWidth = aData->mCbCrSize.width;
+  vchannel->mHeight = aData->mCbCrSize.height;
+  vchannel->mDataType = ChannelPixelLayoutDataType::Uint8;
+  vchannel->mStride = aData->mCbCrStride;
+  vchannel->mSkip = aData->mCrSkip;
+
+  return layout;
+}
+
+uint8_t
+GetChannelCountOfImageFormat(ImageBitmapFormat aFormat)
+{
+  UtilsUniquePtr format = Utils::GetUtils(aFormat);
+  MOZ_ASSERT(format, "Cannot get a valid ImageBitmapFormatUtils instance.");
+
+  return format->GetChannelCount();
+}
+
+uint32_t
+CalculateImageBufferSize(ImageBitmapFormat aFormat,
+                         uint32_t aWidth, uint32_t aHeight)
+{
+  UtilsUniquePtr format = Utils::GetUtils(aFormat);
+  MOZ_ASSERT(format, "Cannot get a valid ImageBitmapFormatUtils instance.");
+
+  return format->NeededBufferSize(aWidth, aHeight);
+}
+
+UniquePtr<ImagePixelLayout>
+CopyAndConvertImageData(ImageBitmapFormat aSrcFormat,
+                        const uint8_t* aSrcBuffer,
+                        const ImagePixelLayout* aSrcLayout,
+                        ImageBitmapFormat aDstFormat,
+                        uint8_t* aDstBuffer)
+{
+  MOZ_ASSERT(aSrcBuffer, "Convert color from a null buffer.");
+  MOZ_ASSERT(aSrcLayout, "Convert color from a null layout.");
+  MOZ_ASSERT(aDstBuffer, "Convert color to a null buffer.");
+
+  UtilsUniquePtr srcFormat = Utils::GetUtils(aSrcFormat);
+  UtilsUniquePtr dstFormat = Utils::GetUtils(aDstFormat);
+  MOZ_ASSERT(srcFormat, "Cannot get a valid ImageBitmapFormatUtils instance.");
+  MOZ_ASSERT(dstFormat, "Cannot get a valid ImageBitmapFormatUtils instance.");
+
+  return srcFormat->ConvertTo(dstFormat.get(), aSrcBuffer, aSrcLayout, aDstBuffer);
+}
+
+ImageBitmapFormat
+FindBestMatchingFromat(ImageBitmapFormat aSrcFormat,
+                       const Sequence<ImageBitmapFormat>& aCandidates) {
+
+  for(auto& candidate : aCandidates) {
+    UtilsUniquePtr candidateFormat = Utils::GetUtils(candidate);
+    MOZ_ASSERT(candidateFormat, "Cannot get a valid ImageBitmapFormatUtils instance.");
+
+    if (candidateFormat->CanConvertFrom(aSrcFormat)) {
+      return candidate;
+    }
+  }
+
+  return ImageBitmapFormat::EndGuard_;
+}
+
+} // namespace dom
+} // namespace mozilla