text: /*
   *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
   *
   *  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/rotate.h"
  
  #include "libyuv/cpu_id.h"
  #include "libyuv/convert.h"
  #include "libyuv/planar_functions.h"
  #include "libyuv/rotate_row.h"
  #include "libyuv/row.h"
  
  #ifdef __cplusplus
  namespace libyuv {
  extern "C" {
  #endif
  
  LIBYUV_API
  void TransposePlane(const uint8* src, int src_stride,
                      uint8* dst, int dst_stride,
                      int width, int height) {
    int i = height;
    void (*TransposeWx8)(const uint8* src, int src_stride,
                         uint8* dst, int dst_stride, int width) = TransposeWx8_C;
  #if defined(HAS_TRANSPOSEWX8_NEON)
    if (TestCpuFlag(kCpuHasNEON)) {
      TransposeWx8 = TransposeWx8_NEON;
    }
  #endif
  #if defined(HAS_TRANSPOSEWX8_SSSE3)
    if (TestCpuFlag(kCpuHasSSSE3)) {
      TransposeWx8 = TransposeWx8_Any_SSSE3;
      if (IS_ALIGNED(width, 8)) {
        TransposeWx8 = TransposeWx8_SSSE3;
      }
    }
  #endif
  #if defined(HAS_TRANSPOSEWX8_FAST_SSSE3)
    if (TestCpuFlag(kCpuHasSSSE3)) {
      TransposeWx8 = TransposeWx8_Fast_Any_SSSE3;
      if (IS_ALIGNED(width, 16)) {
        TransposeWx8 = TransposeWx8_Fast_SSSE3;
      }
    }
  #endif
  #if defined(HAS_TRANSPOSEWX8_MIPS_DSPR2)
    if (TestCpuFlag(kCpuHasMIPS_DSPR2)) {
      if (IS_ALIGNED(width, 4) &&
          IS_ALIGNED(src, 4) && IS_ALIGNED(src_stride, 4)) {
        TransposeWx8 = TransposeWx8_Fast_MIPS_DSPR2;
      } else {
        TransposeWx8 = TransposeWx8_MIPS_DSPR2;
      }
    }
  #endif
  
    // Work across the source in 8x8 tiles
    while (i >= 8) {
      TransposeWx8(src, src_stride, dst, dst_stride, width);
      src += 8 * src_stride;    // Go down 8 rows.
      dst += 8;                 // Move over 8 columns.
      i -= 8;
    }
  
    if (i > 0) {
      TransposeWxH_C(src, src_stride, dst, dst_stride, width, i);
    }
  }
  
  LIBYUV_API
  void RotatePlane90(const uint8* src, int src_stride,
                     uint8* dst, int dst_stride,
                     int width, int height) {
    // Rotate by 90 is a transpose with the source read
    // from bottom to top. So set the source pointer to the end
    // of the buffer and flip the sign of the source stride.
    src += src_stride * (height - 1);
    src_stride = -src_stride;
    TransposePlane(src, src_stride, dst, dst_stride, width, height);
  }
  
  LIBYUV_API
  void RotatePlane270(const uint8* src, int src_stride,
                      uint8* dst, int dst_stride,
                      int width, int height) {
    // Rotate by 270 is a transpose with the destination written
    // from bottom to top. So set the destination pointer to the end
    // of the buffer and flip the sign of the destination stride.
    dst += dst_stride * (width - 1);
    dst_stride = -dst_stride;
    TransposePlane(src, src_stride, dst, dst_stride, width, height);
  }
  
  LIBYUV_API
  void RotatePlane180(const uint8* src, int src_stride,
                      uint8* dst, int dst_stride,
                      int width, int height) {
    // Swap first and last row and mirror the content. Uses a temporary row.
    align_buffer_64(row, width);
    const uint8* src_bot = src + src_stride * (height - 1);
    uint8* dst_bot = dst + dst_stride * (height - 1);
    int half_height = (height + 1) >> 1;
    int y;
    void (*MirrorRow)(const uint8* src, uint8* dst, int width) = MirrorRow_C;
    void (*CopyRow)(const uint8* src, uint8* dst, int width) = CopyRow_C;
  #if defined(HAS_MIRRORROW_NEON)
    if (TestCpuFlag(kCpuHasNEON)) {
      MirrorRow = MirrorRow_Any_NEON;
      if (IS_ALIGNED(width, 16)) {
        MirrorRow = MirrorRow_NEON;
      }
    }
  #endif
  #if defined(HAS_MIRRORROW_SSE2)
    if (TestCpuFlag(kCpuHasSSE2)) {
      MirrorRow = MirrorRow_Any_SSE2;
      if (IS_ALIGNED(width, 16)) {
        MirrorRow = MirrorRow_SSE2;
      }
    }
  #endif
  #if defined(HAS_MIRRORROW_SSSE3)
    if (TestCpuFlag(kCpuHasSSSE3)) {
      MirrorRow = MirrorRow_Any_SSSE3;
      if (IS_ALIGNED(width, 16)) {
        MirrorRow = MirrorRow_SSSE3;
      }
    }
  #endif
  #if defined(HAS_MIRRORROW_AVX2)
    if (TestCpuFlag(kCpuHasAVX2)) {
      MirrorRow = MirrorRow_Any_AVX2;
      if (IS_ALIGNED(width, 32)) {
        MirrorRow = MirrorRow_AVX2;
      }
    }
  #endif
  // TODO(fbarchard): Mirror on mips handle unaligned memory.
  #if defined(HAS_MIRRORROW_MIPS_DSPR2)
    if (TestCpuFlag(kCpuHasMIPS_DSPR2) &&
        IS_ALIGNED(src, 4) && IS_ALIGNED(src_stride, 4) &&
        IS_ALIGNED(dst, 4) && IS_ALIGNED(dst_stride, 4)) {
      MirrorRow = MirrorRow_MIPS_DSPR2;
    }
  #endif
  #if defined(HAS_COPYROW_SSE2)
    if (TestCpuFlag(kCpuHasSSE2)) {
      CopyRow = IS_ALIGNED(width, 32) ? CopyRow_SSE2 : CopyRow_Any_SSE2;
    }
  #endif
  #if defined(HAS_COPYROW_AVX)
    if (TestCpuFlag(kCpuHasAVX)) {
      CopyRow = IS_ALIGNED(width, 64) ? CopyRow_AVX : CopyRow_Any_AVX;
    }
  #endif
  #if defined(HAS_COPYROW_ERMS)
    if (TestCpuFlag(kCpuHasERMS)) {
      CopyRow = CopyRow_ERMS;
    }
  #endif
  #if defined(HAS_COPYROW_NEON)
    if (TestCpuFlag(kCpuHasNEON)) {
      CopyRow = IS_ALIGNED(width, 32) ? CopyRow_NEON : CopyRow_Any_NEON;
    }
  #endif
  #if defined(HAS_COPYROW_MIPS)
    if (TestCpuFlag(kCpuHasMIPS)) {
      CopyRow = CopyRow_MIPS;
    }
  #endif
  
    // Odd height will harmlessly mirror the middle row twice.
    for (y = 0; y < half_height; ++y) {
      MirrorRow(src, row, width);  // Mirror first row into a buffer
      src += src_stride;
      MirrorRow(src_bot, dst, width);  // Mirror last row into first row
      dst += dst_stride;
      CopyRow(row, dst_bot, width);  // Copy first mirrored row into last
      src_bot -= src_stride;
      dst_bot -= dst_stride;
    }
    free_aligned_buffer_64(row);
  }
  
  LIBYUV_API
  void TransposeUV(const uint8* src, int src_stride,
                   uint8* dst_a, int dst_stride_a,
                   uint8* dst_b, int dst_stride_b,
                   int width, int height) {
    int i = height;
    void (*TransposeUVWx8)(const uint8* src, int src_stride,
                           uint8* dst_a, int dst_stride_a,
                           uint8* dst_b, int dst_stride_b,
                           int width) = TransposeUVWx8_C;
  #if defined(HAS_TRANSPOSEUVWX8_NEON)
    if (TestCpuFlag(kCpuHasNEON)) {
      TransposeUVWx8 = TransposeUVWx8_NEON;
    }
  #endif
  #if defined(HAS_TRANSPOSEUVWX8_SSE2)
    if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(width, 8)) {
      TransposeUVWx8 = TransposeUVWx8_SSE2;
    }
  #endif
  #if defined(HAS_TRANSPOSEUVWx8_MIPS_DSPR2)
    if (TestCpuFlag(kCpuHasMIPS_DSPR2) && IS_ALIGNED(width, 2) &&
        IS_ALIGNED(src, 4) && IS_ALIGNED(src_stride, 4)) {
      TransposeUVWx8 = TransposeUVWx8_MIPS_DSPR2;
    }
  #endif
  
    // Work through the source in 8x8 tiles.
    while (i >= 8) {
      TransposeUVWx8(src, src_stride,
                     dst_a, dst_stride_a,
                     dst_b, dst_stride_b,
                     width);
      src += 8 * src_stride;    // Go down 8 rows.
      dst_a += 8;               // Move over 8 columns.
      dst_b += 8;               // Move over 8 columns.
      i -= 8;
    }
  
    if (i > 0) {
      TransposeUVWxH_C(src, src_stride,
                       dst_a, dst_stride_a,
                       dst_b, dst_stride_b,
                       width, i);
    }
  }
  
  LIBYUV_API
  void RotateUV90(const uint8* src, int src_stride,
                  uint8* dst_a, int dst_stride_a,
                  uint8* dst_b, int dst_stride_b,
                  int width, int height) {
    src += src_stride * (height - 1);
    src_stride = -src_stride;
  
    TransposeUV(src, src_stride,
                dst_a, dst_stride_a,
                dst_b, dst_stride_b,
                width, height);
  }
  
  LIBYUV_API
  void RotateUV270(const uint8* src, int src_stride,
                   uint8* dst_a, int dst_stride_a,
                   uint8* dst_b, int dst_stride_b,
                   int width, int height) {
    dst_a += dst_stride_a * (width - 1);
    dst_b += dst_stride_b * (width - 1);
    dst_stride_a = -dst_stride_a;
    dst_stride_b = -dst_stride_b;
  
    TransposeUV(src, src_stride,
                dst_a, dst_stride_a,
                dst_b, dst_stride_b,
                width, height);
  }
  
  // Rotate 180 is a horizontal and vertical flip.
  LIBYUV_API
  void RotateUV180(const uint8* src, int src_stride,
                   uint8* dst_a, int dst_stride_a,
                   uint8* dst_b, int dst_stride_b,
                   int width, int height) {
    int i;
    void (*MirrorRowUV)(const uint8* src, uint8* dst_u, uint8* dst_v, int width) =
        MirrorUVRow_C;
  #if defined(HAS_MIRRORUVROW_NEON)
    if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 8)) {
      MirrorRowUV = MirrorUVRow_NEON;
    }
  #endif
  #if defined(HAS_MIRRORROW_UV_SSSE3)
    if (TestCpuFlag(kCpuHasSSSE3) && IS_ALIGNED(width, 16)) {
      MirrorRowUV = MirrorUVRow_SSSE3;
    }
  #endif
  #if defined(HAS_MIRRORUVROW_MIPS_DSPR2)
    if (TestCpuFlag(kCpuHasMIPS_DSPR2) &&
        IS_ALIGNED(src, 4) && IS_ALIGNED(src_stride, 4)) {
      MirrorRowUV = MirrorUVRow_MIPS_DSPR2;
    }
  #endif
  
    dst_a += dst_stride_a * (height - 1);
    dst_b += dst_stride_b * (height - 1);
  
    for (i = 0; i < height; ++i) {
      MirrorRowUV(src, dst_a, dst_b, width);
      src += src_stride;
      dst_a -= dst_stride_a;
      dst_b -= dst_stride_b;
    }
  }
  
  LIBYUV_API
  int RotatePlane(const uint8* src, int src_stride,
                  uint8* dst, int dst_stride,
                  int width, int height,
                  enum RotationMode mode) {
    if (!src || width <= 0 || height == 0 || !dst) {
      return -1;
    }
  
    // Negative height means invert the image.
    if (height < 0) {
      height = -height;
      src = src + (height - 1) * src_stride;
      src_stride = -src_stride;
    }
  
    switch (mode) {
      case kRotate0:
        // copy frame
        CopyPlane(src, src_stride,
                  dst, dst_stride,
                  width, height);
        return 0;
      case kRotate90:
        RotatePlane90(src, src_stride,
                      dst, dst_stride,
                      width, height);
        return 0;
      case kRotate270:
        RotatePlane270(src, src_stride,
                       dst, dst_stride,
                       width, height);
        return 0;
      case kRotate180:
        RotatePlane180(src, src_stride,
                       dst, dst_stride,
                       width, height);
        return 0;
      default:
        break;
    }
    return -1;
  }
  
  LIBYUV_API
  int I420Rotate(const uint8* src_y, int src_stride_y,
                 const uint8* src_u, int src_stride_u,
                 const uint8* src_v, int src_stride_v,
                 uint8* dst_y, int dst_stride_y,
                 uint8* dst_u, int dst_stride_u,
                 uint8* dst_v, int dst_stride_v,
                 int width, int height,
                 enum RotationMode mode) {
    int halfwidth = (width + 1) >> 1;
    int halfheight = (height + 1) >> 1;
    if (!src_y || !src_u || !src_v || width <= 0 || height == 0 ||
        !dst_y || !dst_u || !dst_v) {
      return -1;
    }
  
    // Negative height means invert the image.
    if (height < 0) {
      height = -height;
      halfheight = (height + 1) >> 1;
      src_y = src_y + (height - 1) * src_stride_y;
      src_u = src_u + (halfheight - 1) * src_stride_u;
      src_v = src_v + (halfheight - 1) * src_stride_v;
      src_stride_y = -src_stride_y;
      src_stride_u = -src_stride_u;
      src_stride_v = -src_stride_v;
    }
  
    switch (mode) {
      case kRotate0:
        // copy frame
        return I420Copy(src_y, src_stride_y,
                        src_u, src_stride_u,
                        src_v, src_stride_v,
                        dst_y, dst_stride_y,
                        dst_u, dst_stride_u,
                        dst_v, dst_stride_v,
                        width, height);
      case kRotate90:
        RotatePlane90(src_y, src_stride_y,
                      dst_y, dst_stride_y,
                      width, height);
        RotatePlane90(src_u, src_stride_u,
                      dst_u, dst_stride_u,
                      halfwidth, halfheight);
        RotatePlane90(src_v, src_stride_v,
                      dst_v, dst_stride_v,
                      halfwidth, halfheight);
        return 0;
      case kRotate270:
        RotatePlane270(src_y, src_stride_y,
                       dst_y, dst_stride_y,
                       width, height);
        RotatePlane270(src_u, src_stride_u,
                       dst_u, dst_stride_u,
                       halfwidth, halfheight);
        RotatePlane270(src_v, src_stride_v,
                       dst_v, dst_stride_v,
                       halfwidth, halfheight);
        return 0;
      case kRotate180:
        RotatePlane180(src_y, src_stride_y,
                       dst_y, dst_stride_y,
                       width, height);
        RotatePlane180(src_u, src_stride_u,
                       dst_u, dst_stride_u,
                       halfwidth, halfheight);
        RotatePlane180(src_v, src_stride_v,
                       dst_v, dst_stride_v,
                       halfwidth, halfheight);
        return 0;
      default:
        break;
    }
    return -1;
  }
  
  LIBYUV_API
  int NV12ToI420Rotate(const uint8* src_y, int src_stride_y,
                       const uint8* src_uv, int src_stride_uv,
                       uint8* dst_y, int dst_stride_y,
                       uint8* dst_u, int dst_stride_u,
                       uint8* dst_v, int dst_stride_v,
                       int width, int height,
                       enum RotationMode mode) {
    int halfwidth = (width + 1) >> 1;
    int halfheight = (height + 1) >> 1;
    if (!src_y || !src_uv || width <= 0 || height == 0 ||
        !dst_y || !dst_u || !dst_v) {
      return -1;
    }
  
    // Negative height means invert the image.
    if (height < 0) {
      height = -height;
      halfheight = (height + 1) >> 1;
      src_y = src_y + (height - 1) * src_stride_y;
      src_uv = src_uv + (halfheight - 1) * src_stride_uv;
      src_stride_y = -src_stride_y;
      src_stride_uv = -src_stride_uv;
    }
  
    switch (mode) {
      case kRotate0:
        // copy frame
        return NV12ToI420(src_y, src_stride_y,
                          src_uv, src_stride_uv,
                          dst_y, dst_stride_y,
                          dst_u, dst_stride_u,
                          dst_v, dst_stride_v,
                          width, height);
      case kRotate90:
        RotatePlane90(src_y, src_stride_y,
                      dst_y, dst_stride_y,
                      width, height);
        RotateUV90(src_uv, src_stride_uv,
                   dst_u, dst_stride_u,
                   dst_v, dst_stride_v,
                   halfwidth, halfheight);
        return 0;
      case kRotate270:
        RotatePlane270(src_y, src_stride_y,
                       dst_y, dst_stride_y,
                       width, height);
        RotateUV270(src_uv, src_stride_uv,
                    dst_u, dst_stride_u,
                    dst_v, dst_stride_v,
                    halfwidth, halfheight);
        return 0;
      case kRotate180:
        RotatePlane180(src_y, src_stride_y,
                       dst_y, dst_stride_y,
                       width, height);
        RotateUV180(src_uv, src_stride_uv,
                    dst_u, dst_stride_u,
                    dst_v, dst_stride_v,
                    halfwidth, halfheight);
        return 0;
      default:
        break;
    }
    return -1;
  }
  
  #ifdef __cplusplus
  }  // extern "C"
  }  // namespace libyuv
  #endif
  