/*

 *  Copyright 2011 The LibYuv Project Authors. All rights reserved.

 *  Copyright 2016 Mozilla Foundation

 *

 *  Use of this source code is governed by a BSD-style license

 *  that can be found in the LICENSE file in the root of the source

 *  tree. An additional intellectual property rights grant can be found

 *  in the file PATENTS. All contributing project authors may

 *  be found in the AUTHORS file in the root of the source tree.

 */

#include "libyuv/scale.h"

#include <assert.h>

#include <string.h>

#include "libyuv/cpu_id.h"

#include "libyuv/row.h"

#include "libyuv/scale_row.h"

#include "libyuv/video_common.h"

#ifdef __cplusplus

namespace libyuv {

extern "C" {

#endif

// YUV to RGB conversion and scaling functions were implemented by referencing

// scale_argb.cc

//

// libyuv already has ScaleYUVToARGBBilinearUp(), but its implementation is not

// completed yet. Implementations of the functions are based on it.

// At first, ScaleYUVToARGBBilinearUp() was implemented by modidying the

// libyuv's one. Then all another functions were implemented similarly.

//

// Function relationship between yuv_convert.cpp abd scale_argb.cc are like

// the followings

//  - ScaleYUVToARGBDown2()      <-- ScaleARGBDown2()

//  - ScaleYUVToARGBDownEven()   <-- ScaleARGBDownEven()

//  - ScaleYUVToARGBBilinearDown() <-- ScaleARGBBilinearDown()

//  - ScaleYUVToARGBBilinearUp() <-- ScaleARGBBilinearUp() and ScaleYUVToARGBBilinearUp() in libyuv

//  - ScaleYUVToARGBSimple()     <-- ScaleARGBSimple()

//  - ScaleYUVToARGB()           <-- ScaleARGB() // Removed some function calls for simplicity.

//  - YUVToARGBScale()           <-- ARGBScale()

//

// Callings and selections of InterpolateRow() and ScaleARGBFilterCols() were

// kept as same as possible.

//

// The followings changes were done to each scaling functions.

//

// -[1] Allocate YUV conversion buffer and use it as source buffer of scaling.

//      Its usage is borrowed from the libyuv's ScaleYUVToARGBBilinearUp().

// -[2] Conversion from YUV to RGB was abstracted as YUVBuferIter.

//      It is for handling multiple yuv color formats.

// -[3] Modified scaling functions as to handle YUV conversion buffer and

//      use YUVBuferIter.

// -[4] Color conversion function selections in YUVBuferIter were borrowed from

//      I444ToARGBMatrix(), I422ToARGBMatrix() and I420ToARGBMatrix() 

static __inline int Abs(int v) {

  return v >= 0 ? v : -v;

}

struct YUVBuferIter {

  int src_width;

  int src_height;

  int src_stride_y;

  int src_stride_u;

  int src_stride_v;

  const uint8* src_y;

  const uint8* src_u;

  const uint8* src_v;

  uint32 src_fourcc;

  const struct YuvConstants* yuvconstants;

  int y_index;

  const uint8* src_row_y;

  const uint8* src_row_u;

  const uint8* src_row_v;

  void (*YUVToARGBRow)(const uint8* y_buf,

                       const uint8* u_buf,

                       const uint8* v_buf,

                       uint8* rgb_buf,

                       const struct YuvConstants* yuvconstants,

                       int width);

  void (*MoveTo)(YUVBuferIter& iter, int y_index);

  void (*MoveToNextRow)(YUVBuferIter& iter);

};

void YUVBuferIter_InitI422(YUVBuferIter& iter) {

  iter.YUVToARGBRow = I422ToARGBRow_C;

#if defined(HAS_I422TOARGBROW_SSSE3)

  if (TestCpuFlag(kCpuHasSSSE3)) {

    iter.YUVToARGBRow = I422ToARGBRow_Any_SSSE3;

    if (IS_ALIGNED(iter.src_width, 8)) {

      iter.YUVToARGBRow = I422ToARGBRow_SSSE3;

    }

  }

#endif

#if defined(HAS_I422TOARGBROW_AVX2)

  if (TestCpuFlag(kCpuHasAVX2)) {

    iter.YUVToARGBRow = I422ToARGBRow_Any_AVX2;

    if (IS_ALIGNED(iter.src_width, 16)) {

      iter.YUVToARGBRow = I422ToARGBRow_AVX2;

    }

  }

#endif

#if defined(HAS_I422TOARGBROW_NEON)

  if (TestCpuFlag(kCpuHasNEON)) {

    iter.YUVToARGBRow = I422ToARGBRow_Any_NEON;

    if (IS_ALIGNED(iter.src_width, 8)) {

      iter.YUVToARGBRow = I422ToARGBRow_NEON;

    }

  }

#endif

#if defined(HAS_I422TOARGBROW_DSPR2)

  if (TestCpuFlag(kCpuHasDSPR2) && IS_ALIGNED(iter.src_width, 4) &&

      IS_ALIGNED(iter.src_y, 4) && IS_ALIGNED(iter.src_stride_y, 4) &&

      IS_ALIGNED(iter.src_u, 2) && IS_ALIGNED(iter.src_stride_u, 2) &&

      IS_ALIGNED(iter.src_v, 2) && IS_ALIGNED(iter.src_stride_v, 2) {

    // Always satisfy IS_ALIGNED(argb_cnv_row, 4) && IS_ALIGNED(argb_cnv_rowstride, 4)

    iter.YUVToARGBRow = I422ToARGBRow_DSPR2;

  }

#endif

}

void YUVBuferIter_InitI444(YUVBuferIter& iter) {

  iter.YUVToARGBRow = I444ToARGBRow_C;

#if defined(HAS_I444TOARGBROW_SSSE3)

  if (TestCpuFlag(kCpuHasSSSE3)) {

    iter.YUVToARGBRow = I444ToARGBRow_Any_SSSE3;

    if (IS_ALIGNED(iter.src_width, 8)) {

      iter.YUVToARGBRow = I444ToARGBRow_SSSE3;

    }

  }

#endif

#if defined(HAS_I444TOARGBROW_AVX2)

  if (TestCpuFlag(kCpuHasAVX2)) {

    iter.YUVToARGBRow = I444ToARGBRow_Any_AVX2;

    if (IS_ALIGNED(iter.src_width, 16)) {

      iter.YUVToARGBRow = I444ToARGBRow_AVX2;

    }

  }

#endif

#if defined(HAS_I444TOARGBROW_NEON)

  if (TestCpuFlag(kCpuHasNEON)) {

    iter.YUVToARGBRow = I444ToARGBRow_Any_NEON;

    if (IS_ALIGNED(iter.src_width, 8)) {

      iter.YUVToARGBRow = I444ToARGBRow_NEON;

    }

  }

#endif

}

static void YUVBuferIter_MoveToForI444(YUVBuferIter& iter, int y_index) {

  iter.y_index = y_index;

  iter.src_row_y = iter.src_y + y_index * iter.src_stride_y;

  iter.src_row_u = iter.src_u + y_index * iter.src_stride_u;

  iter.src_row_v = iter.src_v + y_index * iter.src_stride_v;

}

static void YUVBuferIter_MoveToNextRowForI444(YUVBuferIter& iter) {

  iter.src_row_y += iter.src_stride_y;

  iter.src_row_u += iter.src_stride_u;

  iter.src_row_v += iter.src_stride_v;

  iter.y_index++;

}

static void YUVBuferIter_MoveToForI422(YUVBuferIter& iter, int y_index) {

  iter.y_index = y_index;

  iter.src_row_y = iter.src_y + y_index * iter.src_stride_y;

  iter.src_row_u = iter.src_u + y_index * iter.src_stride_u;

  iter.src_row_v = iter.src_v + y_index * iter.src_stride_v;

}

static void YUVBuferIter_MoveToNextRowForI422(YUVBuferIter& iter) {

  iter.src_row_y += iter.src_stride_y;

  iter.src_row_u += iter.src_stride_u;

  iter.src_row_v += iter.src_stride_v;

  iter.y_index++;

}

static void YUVBuferIter_MoveToForI420(YUVBuferIter& iter, int y_index) {

  const int kYShift = 1;  // Shift Y by 1 to convert Y plane to UV coordinate.

  int uv_y_index = y_index >> kYShift;

  iter.y_index = y_index;

  iter.src_row_y = iter.src_y + y_index * iter.src_stride_y;

  iter.src_row_u = iter.src_u + uv_y_index * iter.src_stride_u;

  iter.src_row_v = iter.src_v + uv_y_index * iter.src_stride_v;

}

static void YUVBuferIter_MoveToNextRowForI420(YUVBuferIter& iter) {

  iter.src_row_y += iter.src_stride_y;

  if (iter.y_index & 1) {

    iter.src_row_u += iter.src_stride_u;

    iter.src_row_v += iter.src_stride_v;

  }

  iter.y_index++;

}

static __inline void YUVBuferIter_ConvertToARGBRow(YUVBuferIter& iter, uint8* argb_row) {

  iter.YUVToARGBRow(iter.src_row_y, iter.src_row_u, iter.src_row_v, argb_row, iter.yuvconstants, iter.src_width);

}

void YUVBuferIter_Init(YUVBuferIter& iter, uint32 src_fourcc, mozilla::YUVColorSpace yuv_color_space) {

  iter.src_fourcc = src_fourcc;

  iter.y_index = 0;

  iter.src_row_y = iter.src_y;

  iter.src_row_u = iter.src_u;

  iter.src_row_v = iter.src_v;

  if (yuv_color_space == mozilla::YUVColorSpace::BT709) {

    iter.yuvconstants = &kYuvH709Constants;

  } else {

    iter.yuvconstants = &kYuvI601Constants;

  }

  if (src_fourcc == FOURCC_I444) {

    YUVBuferIter_InitI444(iter);

    iter.MoveTo = YUVBuferIter_MoveToForI444;

    iter.MoveToNextRow = YUVBuferIter_MoveToNextRowForI444;

  } else if(src_fourcc == FOURCC_I422){

    YUVBuferIter_InitI422(iter);

    iter.MoveTo = YUVBuferIter_MoveToForI422;

    iter.MoveToNextRow = YUVBuferIter_MoveToNextRowForI422;

  } else {

    assert(src_fourcc == FOURCC_I420); // Should be FOURCC_I420

    YUVBuferIter_InitI422(iter);

    iter.MoveTo = YUVBuferIter_MoveToForI420;

    iter.MoveToNextRow = YUVBuferIter_MoveToNextRowForI420;

  }

}

// ScaleARGB ARGB, 1/2

// This is an optimized version for scaling down a ARGB to 1/2 of

// its original size.

static void ScaleYUVToARGBDown2(int src_width, int src_height,

                                int dst_width, int dst_height,

                                int src_stride_y,

                                int src_stride_u,

                                int src_stride_v,

                                int dst_stride_argb,

                                const uint8* src_y,

                                const uint8* src_u,

                                const uint8* src_v,

                                uint8* dst_argb,

                                int x, int dx, int y, int dy,

                                enum FilterMode filtering,

                                uint32 src_fourcc,

                                mozilla::YUVColorSpace yuv_color_space) {

  int j;

  // Allocate 2 rows of ARGB for source conversion.

  const int kRowSize = (src_width * 4 + 15) & ~15;

  align_buffer_64(argb_cnv_row, kRowSize * 2);

  uint8* argb_cnv_rowptr = argb_cnv_row;

  int argb_cnv_rowstride = kRowSize;

  YUVBuferIter iter;

  iter.src_width = src_width;

  iter.src_height = src_height;

  iter.src_stride_y = src_stride_y;

  iter.src_stride_u = src_stride_u;

  iter.src_stride_v = src_stride_v;

  iter.src_y = src_y;

  iter.src_u = src_u;

  iter.src_v = src_v;

  YUVBuferIter_Init(iter, src_fourcc, yuv_color_space);

  void (*ScaleARGBRowDown2)(const uint8* src_argb, ptrdiff_t src_stride,

                            uint8* dst_argb, int dst_width) =

    filtering == kFilterNone ? ScaleARGBRowDown2_C :

        (filtering == kFilterLinear ? ScaleARGBRowDown2Linear_C :

        ScaleARGBRowDown2Box_C);

  assert(dx == 65536 * 2);  // Test scale factor of 2.

  assert((dy & 0x1ffff) == 0);  // Test vertical scale is multiple of 2.

  // Advance to odd row, even column.

  int yi = y >> 16;

  iter.MoveTo(iter, yi);

  ptrdiff_t x_offset;

  if (filtering == kFilterBilinear) {

    x_offset = (x >> 16) * 4;

  } else {

    x_offset = ((x >> 16) - 1) * 4;

  }

#if defined(HAS_SCALEARGBROWDOWN2_SSE2)

  if (TestCpuFlag(kCpuHasSSE2)) {

    ScaleARGBRowDown2 = filtering == kFilterNone ? ScaleARGBRowDown2_Any_SSE2 :

        (filtering == kFilterLinear ? ScaleARGBRowDown2Linear_Any_SSE2 :

        ScaleARGBRowDown2Box_Any_SSE2);

    if (IS_ALIGNED(dst_width, 4)) {

      ScaleARGBRowDown2 = filtering == kFilterNone ? ScaleARGBRowDown2_SSE2 :

          (filtering == kFilterLinear ? ScaleARGBRowDown2Linear_SSE2 :

          ScaleARGBRowDown2Box_SSE2);

    }

  }

#endif

#if defined(HAS_SCALEARGBROWDOWN2_NEON)

  if (TestCpuFlag(kCpuHasNEON)) {

    ScaleARGBRowDown2 = filtering == kFilterNone ? ScaleARGBRowDown2_Any_NEON :

        (filtering == kFilterLinear ? ScaleARGBRowDown2Linear_Any_NEON :

        ScaleARGBRowDown2Box_Any_NEON);

    if (IS_ALIGNED(dst_width, 8)) {

      ScaleARGBRowDown2 = filtering == kFilterNone ? ScaleARGBRowDown2_NEON :

          (filtering == kFilterLinear ? ScaleARGBRowDown2Linear_NEON :

          ScaleARGBRowDown2Box_NEON);

    }

  }

#endif

  const int dyi = dy >> 16;

  int lastyi = yi;

  YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr);

  // Prepare next row if necessary

  if (filtering != kFilterLinear) {

    if ((yi + dyi) < (src_height - 1)) {

      iter.MoveTo(iter, yi + dyi);

      YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr + argb_cnv_rowstride);

    } else {

      argb_cnv_rowstride = 0;

    }

  }

  if (filtering == kFilterLinear) {

    argb_cnv_rowstride = 0;

  }

  const int max_yi = src_height - 1;

  const int max_yi_minus_dyi = max_yi - dyi;

  for (j = 0; j < dst_height; ++j) {

    if (yi != lastyi) {

      if (yi > max_yi) {

        yi = max_yi;

      }

      if (yi != lastyi) {

        if (filtering == kFilterLinear) {

          iter.MoveTo(iter, yi);

          YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr);

          lastyi = yi;

        } else {

          // Prepare current row

          if (yi == iter.y_index) {

            argb_cnv_rowptr = argb_cnv_rowptr + argb_cnv_rowstride;

            argb_cnv_rowstride = - argb_cnv_rowstride;

          } else {

            iter.MoveTo(iter, yi);

            argb_cnv_rowptr = argb_cnv_row;

            argb_cnv_rowstride = kRowSize;

            YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr);

          }

          // Prepare next row if necessary

          if (iter.y_index  < max_yi) {

            int next_yi = yi < max_yi_minus_dyi ? yi + dyi : max_yi;

            iter.MoveTo(iter, next_yi);

            YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr + argb_cnv_rowstride);

          } else {

            argb_cnv_rowstride = 0;

          }

          lastyi = yi;

        }

      }

    }

    ScaleARGBRowDown2(argb_cnv_rowptr + x_offset, argb_cnv_rowstride, dst_argb, dst_width);

    dst_argb += dst_stride_argb;

    yi += dyi;

  }

  free_aligned_buffer_64(argb_cnv_row);

}

// ScaleARGB ARGB Even

// This is an optimized version for scaling down a ARGB to even

// multiple of its original size.

static void ScaleYUVToARGBDownEven(int src_width, int src_height,

                                   int dst_width, int dst_height,

                                   int src_stride_y,

                                   int src_stride_u,

                                   int src_stride_v,

                                   int dst_stride_argb,

                                   const uint8* src_y,

                                   const uint8* src_u,

                                   const uint8* src_v,

                                   uint8* dst_argb,

                                   int x, int dx, int y, int dy,

                                   enum FilterMode filtering,

                                   uint32 src_fourcc,

                                   mozilla::YUVColorSpace yuv_color_space) {

  int j;

  // Allocate 2 rows of ARGB for source conversion.

  const int kRowSize = (src_width * 4 + 15) & ~15;

  align_buffer_64(argb_cnv_row, kRowSize * 2);

  uint8* argb_cnv_rowptr = argb_cnv_row;

  int argb_cnv_rowstride = kRowSize;

  int col_step = dx >> 16;

  void (*ScaleARGBRowDownEven)(const uint8* src_argb, ptrdiff_t src_stride,

                               int src_step, uint8* dst_argb, int dst_width) =

      filtering ? ScaleARGBRowDownEvenBox_C : ScaleARGBRowDownEven_C;

  assert(IS_ALIGNED(src_width, 2));

  assert(IS_ALIGNED(src_height, 2));

  int yi = y >> 16;

  const ptrdiff_t x_offset = (x >> 16) * 4;

#if defined(HAS_SCALEARGBROWDOWNEVEN_SSE2)

  if (TestCpuFlag(kCpuHasSSE2)) {

    ScaleARGBRowDownEven = filtering ? ScaleARGBRowDownEvenBox_Any_SSE2 :

        ScaleARGBRowDownEven_Any_SSE2;

    if (IS_ALIGNED(dst_width, 4)) {

      ScaleARGBRowDownEven = filtering ? ScaleARGBRowDownEvenBox_SSE2 :

          ScaleARGBRowDownEven_SSE2;

    }

  }

#endif

#if defined(HAS_SCALEARGBROWDOWNEVEN_NEON)

  if (TestCpuFlag(kCpuHasNEON)) {

    ScaleARGBRowDownEven = filtering ? ScaleARGBRowDownEvenBox_Any_NEON :

        ScaleARGBRowDownEven_Any_NEON;

    if (IS_ALIGNED(dst_width, 4)) {

      ScaleARGBRowDownEven = filtering ? ScaleARGBRowDownEvenBox_NEON :

          ScaleARGBRowDownEven_NEON;

    }

  }

#endif

  YUVBuferIter iter;

  iter.src_width = src_width;

  iter.src_height = src_height;

  iter.src_stride_y = src_stride_y;

  iter.src_stride_u = src_stride_u;

  iter.src_stride_v = src_stride_v;

  iter.src_y = src_y;

  iter.src_u = src_u;

  iter.src_v = src_v;

  YUVBuferIter_Init(iter, src_fourcc, yuv_color_space);

  const int dyi = dy >> 16;

  int lastyi = yi;

  YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr);

  // Prepare next row if necessary

  if (filtering != kFilterLinear) {

    if ((yi + dyi) < (src_height - 1)) {

      iter.MoveTo(iter, yi + dyi);

      YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr + argb_cnv_rowstride);

    } else {

      argb_cnv_rowstride = 0;

    }

  }

  if (filtering == kFilterLinear) {

    argb_cnv_rowstride = 0;

  }

  const int max_yi = src_height - 1;

  const int max_yi_minus_dyi = max_yi - dyi;

  for (j = 0; j < dst_height; ++j) {

    if (yi != lastyi) {

      if (yi > max_yi) {

        yi = max_yi;

      }

      if (yi != lastyi) {

        if (filtering == kFilterLinear) {

          iter.MoveTo(iter, yi);

          YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr);

          lastyi = yi;

        } else {

          // Prepare current row

          if (yi == iter.y_index) {

            argb_cnv_rowptr = argb_cnv_rowptr + argb_cnv_rowstride;

            argb_cnv_rowstride = - argb_cnv_rowstride;

          } else {

            iter.MoveTo(iter, yi);

            argb_cnv_rowptr = argb_cnv_row;

            argb_cnv_rowstride = kRowSize;

            YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr);

          }

          // Prepare next row if necessary

          if (iter.y_index  < max_yi) {

            int next_yi = yi < max_yi_minus_dyi ? yi + dyi : max_yi;

            iter.MoveTo(iter, next_yi);

            YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr + argb_cnv_rowstride);

          } else {

            argb_cnv_rowstride = 0;

          }

          lastyi = yi;

        }

      }

    }

    ScaleARGBRowDownEven(argb_cnv_rowptr + x_offset, argb_cnv_rowstride, col_step, dst_argb, dst_width);

    dst_argb += dst_stride_argb;

    yi += dyi;

  }

  free_aligned_buffer_64(argb_cnv_row);

}

// Scale YUV to ARGB down with bilinear interpolation.

static void ScaleYUVToARGBBilinearDown(int src_width, int src_height,

                                       int dst_width, int dst_height,

                                       int src_stride_y,

                                       int src_stride_u,

                                       int src_stride_v,

                                       int dst_stride_argb,

                                       const uint8* src_y,

                                       const uint8* src_u,

                                       const uint8* src_v,

                                       uint8* dst_argb,

                                       int x, int dx, int y, int dy,

                                       enum FilterMode filtering,

                                       uint32 src_fourcc,

                                       mozilla::YUVColorSpace yuv_color_space) {

  int j;

  void (*InterpolateRow)(uint8* dst_argb, const uint8* src_argb,

      ptrdiff_t src_stride, int dst_width, int source_y_fraction) =

      InterpolateRow_C;

  void (*ScaleARGBFilterCols)(uint8* dst_argb, const uint8* src_argb,

      int dst_width, int x, int dx) =

      (src_width >= 32768) ? ScaleARGBFilterCols64_C : ScaleARGBFilterCols_C;

  int64 xlast = x + (int64)(dst_width - 1) * dx;

  int64 xl = (dx >= 0) ? x : xlast;

  int64 xr = (dx >= 0) ? xlast : x;

  int clip_src_width;

  xl = (xl >> 16) & ~3;  // Left edge aligned.

  xr = (xr >> 16) + 1;  // Right most pixel used.  Bilinear uses 2 pixels.

  xr = (xr + 1 + 3) & ~3;  // 1 beyond 4 pixel aligned right most pixel.

  if (xr > src_width) {

    xr = src_width;

  }

  clip_src_width = (int)(xr - xl) * 4;  // Width aligned to 4.

  const ptrdiff_t xl_offset = xl * 4;

  x -= (int)(xl << 16);

  // Allocate 2 row of ARGB for source conversion.

  const int kRowSize = (src_width * 4 + 15) & ~15;

  align_buffer_64(argb_cnv_row, kRowSize * 2);

  uint8* argb_cnv_rowptr = argb_cnv_row; 

  int argb_cnv_rowstride = kRowSize;

#if defined(HAS_INTERPOLATEROW_SSSE3)

  if (TestCpuFlag(kCpuHasSSSE3)) {

    InterpolateRow = InterpolateRow_Any_SSSE3;

    if (IS_ALIGNED(clip_src_width, 16)) {

      InterpolateRow = InterpolateRow_SSSE3;

    }

  }

#endif

#if defined(HAS_INTERPOLATEROW_AVX2)

  if (TestCpuFlag(kCpuHasAVX2)) {

    InterpolateRow = InterpolateRow_Any_AVX2;

    if (IS_ALIGNED(clip_src_width, 32)) {

      InterpolateRow = InterpolateRow_AVX2;

    }

  }

#endif

#if defined(HAS_INTERPOLATEROW_NEON)

  if (TestCpuFlag(kCpuHasNEON)) {

    InterpolateRow = InterpolateRow_Any_NEON;

    if (IS_ALIGNED(clip_src_width, 16)) {

      InterpolateRow = InterpolateRow_NEON;

    }

  }

#endif

#if defined(HAS_INTERPOLATEROW_DSPR2)

  if (TestCpuFlag(kCpuHasDSPR2) &&

      IS_ALIGNED(src_argb, 4) && IS_ALIGNED(argb_cnv_rowstride, 4)) {

    InterpolateRow = InterpolateRow_Any_DSPR2;

    if (IS_ALIGNED(clip_src_width, 4)) {

      InterpolateRow = InterpolateRow_DSPR2;

    }

  }

#endif

#if defined(HAS_SCALEARGBFILTERCOLS_SSSE3)

  if (TestCpuFlag(kCpuHasSSSE3) && src_width < 32768) {

    ScaleARGBFilterCols = ScaleARGBFilterCols_SSSE3;

  }

#endif

#if defined(HAS_SCALEARGBFILTERCOLS_NEON)

  if (TestCpuFlag(kCpuHasNEON)) {

    ScaleARGBFilterCols = ScaleARGBFilterCols_Any_NEON;

    if (IS_ALIGNED(dst_width, 4)) {

      ScaleARGBFilterCols = ScaleARGBFilterCols_NEON;

    }

  }

#endif

  int yi = y >> 16;

  YUVBuferIter iter;

  iter.src_width = src_width;

  iter.src_height = src_height;

  iter.src_stride_y = src_stride_y;

  iter.src_stride_u = src_stride_u;

  iter.src_stride_v = src_stride_v;

  iter.src_y = src_y;

  iter.src_u = src_u;

  iter.src_v = src_v;

  YUVBuferIter_Init(iter, src_fourcc, yuv_color_space);

  iter.MoveTo(iter, yi);

  // TODO(fbarchard): Consider not allocating row buffer for kFilterLinear.

  // Allocate a row of ARGB.

  align_buffer_64(row, clip_src_width * 4);

  int lastyi = yi;

  YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr);

  // Prepare next row if necessary

  if (filtering != kFilterLinear) {

    if ((yi + 1) < src_height) {

      iter.MoveToNextRow(iter);

      YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr + argb_cnv_rowstride);

    } else {

      argb_cnv_rowstride = 0;

    }

  }

  const int max_y = (src_height - 1) << 16;

  const int max_yi = src_height - 1;

  for (j = 0; j < dst_height; ++j) {

    yi = y >> 16;

    if (yi != lastyi) {

      if (y > max_y) {

        y = max_y;

        yi = y >> 16;

      }

      if (yi != lastyi) {

        if (filtering == kFilterLinear) {

          iter.MoveTo(iter, yi);

          YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr);

          lastyi = yi;

        } else {

          // Prepare current row

          if (yi == iter.y_index) {

            argb_cnv_rowptr = argb_cnv_rowptr + argb_cnv_rowstride;

            argb_cnv_rowstride = - argb_cnv_rowstride;

          } else {

            iter.MoveTo(iter, yi);

            argb_cnv_rowptr = argb_cnv_row;

            argb_cnv_rowstride = kRowSize;

            YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr);

          }

          // Prepare next row if necessary

          if (iter.y_index < max_yi) {

            iter.MoveToNextRow(iter);

            YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_rowptr + argb_cnv_rowstride);

          } else {

            argb_cnv_rowstride = 0;

          }

          lastyi = yi;

        }

      }

    }

    if (filtering == kFilterLinear) {

      ScaleARGBFilterCols(dst_argb, argb_cnv_rowptr + xl_offset, dst_width, x, dx);

    } else {

      int yf = (y >> 8) & 255;

      InterpolateRow(row, argb_cnv_rowptr + xl_offset, argb_cnv_rowstride, clip_src_width, yf);

      ScaleARGBFilterCols(dst_argb, row, dst_width, x, dx);

    }

    dst_argb += dst_stride_argb;

    y += dy;

  }

  free_aligned_buffer_64(row);

  free_aligned_buffer_64(argb_cnv_row);

}

// Scale YUV to ARGB up with bilinear interpolation.

static void ScaleYUVToARGBBilinearUp(int src_width, int src_height,

                                     int dst_width, int dst_height,

                                     int src_stride_y,

                                     int src_stride_u,

                                     int src_stride_v,

                                     int dst_stride_argb,

                                     const uint8* src_y,

                                     const uint8* src_u,

                                     const uint8* src_v,

                                     uint8* dst_argb,

                                     int x, int dx, int y, int dy,

                                     enum FilterMode filtering,

                                     uint32 src_fourcc,

                                     mozilla::YUVColorSpace yuv_color_space) {

  int j;

  void (*InterpolateRow)(uint8* dst_argb, const uint8* src_argb,

      ptrdiff_t src_stride, int dst_width, int source_y_fraction) =

      InterpolateRow_C;

  void (*ScaleARGBFilterCols)(uint8* dst_argb, const uint8* src_argb,

      int dst_width, int x, int dx) =

      filtering ? ScaleARGBFilterCols_C : ScaleARGBCols_C;

  const int max_y = (src_height - 1) << 16;

  // Allocate 1 row of ARGB for source conversion.

  align_buffer_64(argb_cnv_row, src_width * 4);

#if defined(HAS_INTERPOLATEROW_SSSE3)

  if (TestCpuFlag(kCpuHasSSSE3)) {

    InterpolateRow = InterpolateRow_Any_SSSE3;

    if (IS_ALIGNED(dst_width, 4)) {

      InterpolateRow = InterpolateRow_SSSE3;

    }

  }

#endif

#if defined(HAS_INTERPOLATEROW_AVX2)

  if (TestCpuFlag(kCpuHasAVX2)) {

    InterpolateRow = InterpolateRow_Any_AVX2;

    if (IS_ALIGNED(dst_width, 8)) {

      InterpolateRow = InterpolateRow_AVX2;

    }

  }

#endif

#if defined(HAS_INTERPOLATEROW_NEON)

  if (TestCpuFlag(kCpuHasNEON)) {

    InterpolateRow = InterpolateRow_Any_NEON;

    if (IS_ALIGNED(dst_width, 4)) {

      InterpolateRow = InterpolateRow_NEON;

    }

  }

#endif

#if defined(HAS_INTERPOLATEROW_DSPR2)

  if (TestCpuFlag(kCpuHasDSPR2) &&

      IS_ALIGNED(dst_argb, 4) && IS_ALIGNED(dst_stride_argb, 4)) {

    InterpolateRow = InterpolateRow_DSPR2;

  }

#endif

  if (src_width >= 32768) {

    ScaleARGBFilterCols = filtering ?

        ScaleARGBFilterCols64_C : ScaleARGBCols64_C;

  }

#if defined(HAS_SCALEARGBFILTERCOLS_SSSE3)

  if (filtering && TestCpuFlag(kCpuHasSSSE3) && src_width < 32768) {

    ScaleARGBFilterCols = ScaleARGBFilterCols_SSSE3;

  }

#endif

#if defined(HAS_SCALEARGBFILTERCOLS_NEON)

  if (filtering && TestCpuFlag(kCpuHasNEON)) {

    ScaleARGBFilterCols = ScaleARGBFilterCols_Any_NEON;

    if (IS_ALIGNED(dst_width, 4)) {

      ScaleARGBFilterCols = ScaleARGBFilterCols_NEON;

    }

  }

#endif

#if defined(HAS_SCALEARGBCOLS_SSE2)

  if (!filtering && TestCpuFlag(kCpuHasSSE2) && src_width < 32768) {

    ScaleARGBFilterCols = ScaleARGBCols_SSE2;

  }

#endif

#if defined(HAS_SCALEARGBCOLS_NEON)

  if (!filtering && TestCpuFlag(kCpuHasNEON)) {

    ScaleARGBFilterCols = ScaleARGBCols_Any_NEON;

    if (IS_ALIGNED(dst_width, 8)) {

      ScaleARGBFilterCols = ScaleARGBCols_NEON;

    }

  }

#endif

  if (!filtering && src_width * 2 == dst_width && x < 0x8000) {

    ScaleARGBFilterCols = ScaleARGBColsUp2_C;

#if defined(HAS_SCALEARGBCOLSUP2_SSE2)

    if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(dst_width, 8)) {

      ScaleARGBFilterCols = ScaleARGBColsUp2_SSE2;

    }

#endif

  }

  if (y > max_y) {

    y = max_y;

  }

  int yi = y >> 16;

  YUVBuferIter iter;

  iter.src_width = src_width;

  iter.src_height = src_height;

  iter.src_stride_y = src_stride_y;

  iter.src_stride_u = src_stride_u;

  iter.src_stride_v = src_stride_v;

  iter.src_y = src_y;

  iter.src_u = src_u;

  iter.src_v = src_v;

  YUVBuferIter_Init(iter, src_fourcc, yuv_color_space);

  iter.MoveTo(iter, yi);

  // Allocate 2 rows of ARGB.

  const int kRowSize = (dst_width * 4 + 15) & ~15;

  align_buffer_64(row, kRowSize * 2);

  uint8* rowptr = row;

  int rowstride = kRowSize;

  int lastyi = yi;

  YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_row);

  ScaleARGBFilterCols(rowptr, argb_cnv_row, dst_width, x, dx);

  if (filtering == kFilterLinear) {

    rowstride = 0;

  }

  // Prepare next row if necessary

  if (filtering != kFilterLinear) {

    if ((yi + 1) < src_height) {

      iter.MoveToNextRow(iter);

      YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_row);

      ScaleARGBFilterCols(rowptr + rowstride, argb_cnv_row, dst_width, x, dx);

    }else {

      rowstride = 0;

    }

  }

  const int max_yi = src_height - 1;

  for (j = 0; j < dst_height; ++j) {

    yi = y >> 16;

    if (yi != lastyi) {

      if (y > max_y) {

        y = max_y;

        yi = y >> 16;

      }

      if (yi != lastyi) {

        if (filtering == kFilterLinear) {

            iter.MoveToNextRow(iter);

            YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_row);

            ScaleARGBFilterCols(rowptr, argb_cnv_row, dst_width, x, dx);

        } else {

          // Prepare next row if necessary

          if (yi < max_yi) {

            iter.MoveToNextRow(iter);

            rowptr += rowstride;

            rowstride = -rowstride;

            // TODO(fbarchard): Convert the clipped region of row.

            YUVBuferIter_ConvertToARGBRow(iter, argb_cnv_row);

            ScaleARGBFilterCols(rowptr + rowstride, argb_cnv_row, dst_width, x, dx);

          } else {

            rowstride = 0;

          }

        }

        lastyi = yi;

      }

    }

    if (filtering == kFilterLinear) {

      InterpolateRow(dst_argb, rowptr, 0, dst_width * 4, 0);

    } else {

      int yf = (y >> 8) & 255;

      InterpolateRow(dst_argb, rowptr, rowstride, dst_width * 4, yf);

    }

    dst_argb += dst_stride_argb;

    y += dy;

  }

  free_aligned_buffer_64(row);

  free_aligned_buffer_64(argb_cnv_row);

}

// Scale ARGB to/from any dimensions, without interpolation.

// Fixed point math is used for performance: The upper 16 bits

// of x and dx is the integer part of the source position and

// the lower 16 bits are the fixed decimal part.

static void ScaleYUVToARGBSimple(int src_width, int src_height,

                                 int dst_width, int dst_height,

                                 int src_stride_y,

                                 int src_stride_u,

                                 int src_stride_v,

                                 int dst_stride_argb,

                                 const uint8* src_y,

                                 const uint8* src_u,

                                 const uint8* src_v,

                                 uint8* dst_argb,

                                 int x, int dx, int y, int dy,

                                 uint32 src_fourcc,

                                 mozilla::YUVColorSpace yuv_color_space) {

  int j;

  void (*ScaleARGBCols)(uint8* dst_argb, const uint8* src_argb,

      int dst_width, int x, int dx) =

      (src_width >= 32768) ? ScaleARGBCols64_C : ScaleARGBCols_C;

  // Allocate 1 row of ARGB for source conversion.

  align_buffer_64(argb_cnv_row, src_width * 4);

#if defined(HAS_SCALEARGBCOLS_SSE2)

  if (TestCpuFlag(kCpuHasSSE2) && src_width < 32768) {

    ScaleARGBCols = ScaleARGBCols_SSE2;

  }

#endif

#if defined(HAS_SCALEARGBCOLS_NEON)

  if (TestCpuFlag(kCpuHasNEON)) {

    ScaleARGBCols = ScaleARGBCols_Any_NEON;

    if (IS_ALIGNED(dst_width, 8)) {

      ScaleARGBCols = ScaleARGBCols_NEON;

    }

  }

#endif

  if (src_width * 2 == dst_width && x < 0x8000) {

    ScaleARGBCols = ScaleARGBColsUp2_C;

#if defined(HAS_SCALEARGBCOLSUP2_SSE2)

    if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(dst_width, 8)) {

      ScaleARGBCols = ScaleARGBColsUp2_SSE2;

    }

#endif

  }

  int yi = y >> 16;

  YUVBuferIter iter;

  iter.src_width = src_width;

  iter.src_height = src_height;

  iter.src_stride_y = src_stride_y;

  iter.src_stride_u = src_stride_u;

  iter.src_stride_v = src_stride_v;

  iter.src_y = src_y;

  iter.src_u = src_u;

  iter.src_v = src_v;