/* -*- 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/gfx/2D.h"

#include <functional>

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,

                        const std::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);

}

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::CvtSimpleImgToSimpleImg<unsigned char, unsigned char>(mozilla::dom::imagebitmapformat::Utils*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, int, std::__1::function<int (unsigned char const*, int, unsigned char*, int, int, int)> const&)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::CvtSimpleImgToSimpleImg<float, unsigned char>(mozilla::dom::imagebitmapformat::Utils*, float const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, int, std::__1::function<int (float const*, int, unsigned char*, int, int, int)> const&)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::CvtSimpleImgToSimpleImg<unsigned char, float>(mozilla::dom::imagebitmapformat::Utils*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, float*, mozilla::dom::ImageBitmapFormat, int, std::__1::function<int (unsigned char const*, int, float*, int, int, int)> const&)

static UniquePtr<ImagePixelLayout>

CvtYUVImgToSimpleImg(Utils* aSrcUtils, const uint8_t* aSrcBuffer,

                     const ImagePixelLayout* aSrcLayout, uint8_t* aDstBuffer,

                     ImageBitmapFormat aDstFormat, int aDstChannelCount,

                     const std::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,

                    const std::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,

                     const std::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,

                    const std::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);

}

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_HSV, mozilla::dom::imagebitmapformat::Utils_Gray8>(mozilla::dom::imagebitmapformat::Utils_HSV*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_Gray8*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_Lab, mozilla::dom::imagebitmapformat::Utils_Gray8>(mozilla::dom::imagebitmapformat::Utils_Lab*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_Gray8*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV422P, mozilla::dom::imagebitmapformat::Utils_YUV444P>(mozilla::dom::imagebitmapformat::Utils_YUV422P*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV444P*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV12, mozilla::dom::imagebitmapformat::Utils_YUV444P>(mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV12*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV444P*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV21, mozilla::dom::imagebitmapformat::Utils_YUV444P>(mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV21*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV444P*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_HSV, mozilla::dom::imagebitmapformat::Utils_YUV444P>(mozilla::dom::imagebitmapformat::Utils_HSV*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV444P*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_Lab, mozilla::dom::imagebitmapformat::Utils_YUV444P>(mozilla::dom::imagebitmapformat::Utils_Lab*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV444P*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV444P, mozilla::dom::imagebitmapformat::Utils_YUV422P>(mozilla::dom::imagebitmapformat::Utils_YUV444P*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV422P*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV12, mozilla::dom::imagebitmapformat::Utils_YUV422P>(mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV12*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV422P*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV21, mozilla::dom::imagebitmapformat::Utils_YUV422P>(mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV21*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV422P*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_HSV, mozilla::dom::imagebitmapformat::Utils_YUV422P>(mozilla::dom::imagebitmapformat::Utils_HSV*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV422P*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_Lab, mozilla::dom::imagebitmapformat::Utils_YUV422P>(mozilla::dom::imagebitmapformat::Utils_Lab*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV422P*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_HSV, mozilla::dom::imagebitmapformat::Utils_YUV420P>(mozilla::dom::imagebitmapformat::Utils_HSV*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV420P*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_Lab, mozilla::dom::imagebitmapformat::Utils_YUV420P>(mozilla::dom::imagebitmapformat::Utils_Lab*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV420P*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV444P, mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV12>(mozilla::dom::imagebitmapformat::Utils_YUV444P*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV12*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV422P, mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV12>(mozilla::dom::imagebitmapformat::Utils_YUV422P*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV12*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV21, mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV12>(mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV21*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV12*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_HSV, mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV12>(mozilla::dom::imagebitmapformat::Utils_HSV*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV12*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_Lab, mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV12>(mozilla::dom::imagebitmapformat::Utils_Lab*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV12*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV444P, mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV21>(mozilla::dom::imagebitmapformat::Utils_YUV444P*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV21*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV422P, mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV21>(mozilla::dom::imagebitmapformat::Utils_YUV422P*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV21*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV12, mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV21>(mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV12*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV21*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_HSV, mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV21>(mozilla::dom::imagebitmapformat::Utils_HSV*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV21*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_Lab, mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV21>(mozilla::dom::imagebitmapformat::Utils_Lab*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV21*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV444P, mozilla::dom::imagebitmapformat::Utils_HSV>(mozilla::dom::imagebitmapformat::Utils_YUV444P*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_HSV*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV422P, mozilla::dom::imagebitmapformat::Utils_HSV>(mozilla::dom::imagebitmapformat::Utils_YUV422P*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_HSV*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV420P, mozilla::dom::imagebitmapformat::Utils_HSV>(mozilla::dom::imagebitmapformat::Utils_YUV420P*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_HSV*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV12, mozilla::dom::imagebitmapformat::Utils_HSV>(mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV12*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_HSV*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV21, mozilla::dom::imagebitmapformat::Utils_HSV>(mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV21*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_HSV*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_Lab, mozilla::dom::imagebitmapformat::Utils_HSV>(mozilla::dom::imagebitmapformat::Utils_Lab*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_HSV*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV444P, mozilla::dom::imagebitmapformat::Utils_Lab>(mozilla::dom::imagebitmapformat::Utils_YUV444P*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_Lab*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV422P, mozilla::dom::imagebitmapformat::Utils_Lab>(mozilla::dom::imagebitmapformat::Utils_YUV422P*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_Lab*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV420P, mozilla::dom::imagebitmapformat::Utils_Lab>(mozilla::dom::imagebitmapformat::Utils_YUV420P*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_Lab*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV12, mozilla::dom::imagebitmapformat::Utils_Lab>(mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV12*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_Lab*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV21, mozilla::dom::imagebitmapformat::Utils_Lab>(mozilla::dom::imagebitmapformat::Utils_YUV420SP_NV21*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_Lab*)

Unexecuted instantiation: Unified_cpp_dom_canvas0.cpp:mozilla::UniquePtr<nsTArray<mozilla::dom::ChannelPixelLayout>, mozilla::DefaultDelete<nsTArray<mozilla::dom::ChannelPixelLayout> > > mozilla::dom::imagebitmapformat::TwoPassConversion<mozilla::dom::imagebitmapformat::Utils_HSV, mozilla::dom::imagebitmapformat::Utils_Lab>(mozilla::dom::imagebitmapformat::Utils_HSV*, unsigned char const*, nsTArray<mozilla::dom::ChannelPixelLayout> const*, unsigned char*, mozilla::dom::ImageBitmapFormat, mozilla::dom::imagebitmapformat::Utils_Lab*)

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)