xref: /external/libyuv/files/unit_test/rotate_test.cc

/*
 *  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 <stdlib.h>
#include <time.h>

#include "libyuv/rotate.h"
#include "../unit_test/unit_test.h"

namespace libyuv {

void PrintArray(uint8 *array, int w, int h) {
  for (int i = 0; i < h; ++i) {
    for (int j = 0; j < w; ++j) {
      printf("%4d", (signed char)array[i * w + j]);
    }
    printf("\n");
  }
}

TEST_F(libyuvTest, Transpose) {
  int iw, ih, ow, oh;
  int err = 0;

  for (iw = 8; iw < rotate_max_w_ && !err; ++iw) {
    for (ih = 8; ih < rotate_max_h_ && !err; ++ih) {
      int i;
      ow = ih;
      oh = iw;

      align_buffer_16(input, iw * ih)
      align_buffer_16(output_1, ow * oh)
      align_buffer_16(output_2, iw * ih)

      for (i = 0; i < iw * ih; ++i) {
        input[i] = i;
      }

      TransposePlane(input,    iw, output_1, ow, iw, ih);
      TransposePlane(output_1, ow, output_2, oh, ow, oh);

      for (i = 0; i < iw * ih; ++i) {
        if (input[i] != output_2[i]) {
          err++;
        }
      }

      if (err) {
        printf("input %dx%d \n", iw, ih);
        PrintArray(input, iw, ih);

        printf("transpose 1\n");
        PrintArray(output_1, ow, oh);

        printf("transpose 2\n");
        PrintArray(output_2, iw, ih);
      }

      free_aligned_buffer_16(input)
      free_aligned_buffer_16(output_1)
      free_aligned_buffer_16(output_2)
    }
  }

  EXPECT_EQ(0, err);
}

TEST_F(libyuvTest, TransposeUV) {
  int iw, ih, ow, oh;
  int err = 0;

  for (iw = 16; iw < rotate_max_w_ && !err; iw += 2) {
    for (ih = 8; ih < rotate_max_h_ && !err; ++ih) {
      int i;

      ow = ih;
      oh = iw >> 1;

      align_buffer_16(input, iw * ih)
      align_buffer_16(output_a1, ow * oh)
      align_buffer_16(output_b1, ow * oh)
      align_buffer_16(output_a2, iw * ih)
      align_buffer_16(output_b2, iw * ih)

      for (i = 0; i < iw * ih; i += 2) {
        input[i] = i >> 1;
        input[i + 1] = -(i >> 1);
      }

      TransposeUV(input, iw, output_a1, ow, output_b1, ow, iw >> 1, ih);

      TransposePlane(output_a1, ow, output_a2, oh, ow, oh);
      TransposePlane(output_b1, ow, output_b2, oh, ow, oh);

      for (i = 0; i < iw * ih; i += 2) {
        if (input[i] != output_a2[i >> 1]) {
          err++;
        }
        if (input[i + 1] != output_b2[i >> 1]) {
          err++;
        }
      }

      if (err) {
        printf("input %dx%d \n", iw, ih);
        PrintArray(input, iw, ih);

        printf("transpose 1\n");
        PrintArray(output_a1, ow, oh);
        PrintArray(output_b1, ow, oh);

        printf("transpose 2\n");
        PrintArray(output_a2, oh, ow);
        PrintArray(output_b2, oh, ow);
      }

      free_aligned_buffer_16(input)
      free_aligned_buffer_16(output_a1)
      free_aligned_buffer_16(output_b1)
      free_aligned_buffer_16(output_a2)
      free_aligned_buffer_16(output_b2)
    }
  }

  EXPECT_EQ(0, err);
}

TEST_F(libyuvTest, RotatePlane90) {
  int iw, ih, ow, oh;
  int err = 0;

  for (iw = 8; iw < rotate_max_w_ && !err; ++iw) {
    for (ih = 8; ih < rotate_max_h_ && !err; ++ih) {
      int i;

      ow = ih;
      oh = iw;

      align_buffer_16(input, iw * ih)
      align_buffer_16(output_0, iw * ih)
      align_buffer_16(output_90, ow * oh)
      align_buffer_16(output_180, iw * ih)
      align_buffer_16(output_270, ow * oh)

      for (i = 0; i < iw * ih; ++i) {
        input[i] = i;
      }

      RotatePlane90(input,      iw, output_90,  ow, iw, ih);
      RotatePlane90(output_90,  ow, output_180, oh, ow, oh);
      RotatePlane90(output_180, oh, output_270, ow, oh, ow);
      RotatePlane90(output_270, ow, output_0,   iw, ow, oh);

      for (i = 0; i < iw * ih; ++i) {
        if (input[i] != output_0[i]) {
          err++;
        }
      }

      if (err) {
        printf("input %dx%d \n", iw, ih);
        PrintArray(input, iw, ih);

        printf("output 90\n");
        PrintArray(output_90, ow, oh);

        printf("output 180\n");
        PrintArray(output_180, iw, ih);

        printf("output 270\n");
        PrintArray(output_270, ow, oh);

        printf("output 0\n");
        PrintArray(output_0, iw, ih);
      }

      free_aligned_buffer_16(input)
      free_aligned_buffer_16(output_0)
      free_aligned_buffer_16(output_90)
      free_aligned_buffer_16(output_180)
      free_aligned_buffer_16(output_270)
    }
  }

  EXPECT_EQ(0, err);
}

TEST_F(libyuvTest, RotateUV90) {
  int iw, ih, ow, oh;
  int err = 0;

  for (iw = 16; iw < rotate_max_w_ && !err; iw += 2) {
    for (ih = 8; ih < rotate_max_h_ && !err; ++ih) {
      int i;

      ow = ih;
      oh = iw >> 1;

      align_buffer_16(input, iw * ih)
      align_buffer_16(output_0_u, ow * oh)
      align_buffer_16(output_0_v, ow * oh)
      align_buffer_16(output_90_u, ow * oh)
      align_buffer_16(output_90_v, ow * oh)
      align_buffer_16(output_180_u, ow * oh)
      align_buffer_16(output_180_v, ow * oh)

      for (i = 0; i < iw * ih; i += 2) {
        input[i] = i >> 1;
        input[i + 1] = -(i >> 1);
      }

      RotateUV90(input, iw, output_90_u, ow, output_90_v, ow, iw >> 1, ih);

      RotatePlane90(output_90_u, ow, output_180_u, oh, ow, oh);
      RotatePlane90(output_90_v, ow, output_180_v, oh, ow, oh);

      RotatePlane180(output_180_u, ow, output_0_u, ow, ow, oh);
      RotatePlane180(output_180_v, ow, output_0_v, ow, ow, oh);

      for (i = 0; i < (ow * oh); ++i) {
        if (output_0_u[i] != (uint8)i) {
          err++;
        }
        if (output_0_v[i] != (uint8)(-i)) {
          err++;
        }
      }

      if (err) {
        printf("input %dx%d \n", iw, ih);
        PrintArray(input, iw, ih);

        printf("output 90_u\n");
        PrintArray(output_90_u, ow, oh);

        printf("output 90_v\n");
        PrintArray(output_90_v, ow, oh);

        printf("output 180_u\n");
        PrintArray(output_180_u, oh, ow);

        printf("output 180_v\n");
        PrintArray(output_180_v, oh, ow);

        printf("output 0_u\n");
        PrintArray(output_0_u, oh, ow);

        printf("output 0_v\n");
        PrintArray(output_0_v, oh, ow);
      }

      free_aligned_buffer_16(input)
      free_aligned_buffer_16(output_0_u)
      free_aligned_buffer_16(output_0_v)
      free_aligned_buffer_16(output_90_u)
      free_aligned_buffer_16(output_90_v)
      free_aligned_buffer_16(output_180_u)
      free_aligned_buffer_16(output_180_v)
    }
  }

  EXPECT_EQ(0, err);
}

TEST_F(libyuvTest, RotateUV180) {
  int iw, ih, ow, oh;
  int err = 0;

  for (iw = 16; iw < rotate_max_w_ && !err; iw += 2) {
    for (ih = 8; ih < rotate_max_h_ && !err; ++ih) {
      int i;

      ow = iw >> 1;
      oh = ih;

      align_buffer_16(input, iw * ih)
      align_buffer_16(output_0_u, ow * oh)
      align_buffer_16(output_0_v, ow * oh)
      align_buffer_16(output_90_u, ow * oh)
      align_buffer_16(output_90_v, ow * oh)
      align_buffer_16(output_180_u, ow * oh)
      align_buffer_16(output_180_v, ow * oh)

      for (i = 0; i < iw * ih; i += 2) {
        input[i] = i >> 1;
        input[i + 1] = -(i >> 1);
      }

      RotateUV180(input, iw, output_180_u, ow, output_180_v, ow, iw >> 1, ih);

      RotatePlane90(output_180_u, ow, output_90_u, oh, ow, oh);
      RotatePlane90(output_180_v, ow, output_90_v, oh, ow, oh);

      RotatePlane90(output_90_u, oh, output_0_u, ow, oh, ow);
      RotatePlane90(output_90_v, oh, output_0_v, ow, oh, ow);

      for (i = 0; i < (ow * oh); ++i) {
        if (output_0_u[i] != (uint8)i) {
          err++;
        }
        if (output_0_v[i] != (uint8)(-i)) {
          err++;
        }
      }

      if (err) {
        printf("input %dx%d \n", iw, ih);
        PrintArray(input, iw, ih);

        printf("output 180_u\n");
        PrintArray(output_180_u, oh, ow);

        printf("output 180_v\n");
        PrintArray(output_180_v, oh, ow);

        printf("output 90_u\n");
        PrintArray(output_90_u, oh, ow);

        printf("output 90_v\n");
        PrintArray(output_90_v, oh, ow);

        printf("output 0_u\n");
        PrintArray(output_0_u, ow, oh);

        printf("output 0_v\n");
        PrintArray(output_0_v, ow, oh);
      }

      free_aligned_buffer_16(input)
      free_aligned_buffer_16(output_0_u)
      free_aligned_buffer_16(output_0_v)
      free_aligned_buffer_16(output_90_u)
      free_aligned_buffer_16(output_90_v)
      free_aligned_buffer_16(output_180_u)
      free_aligned_buffer_16(output_180_v)
    }
  }

  EXPECT_EQ(0, err);
}

TEST_F(libyuvTest, RotateUV270) {
  int iw, ih, ow, oh;
  int err = 0;

  for (iw = 16; iw < rotate_max_w_ && !err; iw += 2) {
    for (ih = 8; ih < rotate_max_h_ && !err; ++ih) {
      int i;

      ow = ih;
      oh = iw >> 1;

      align_buffer_16(input, iw * ih)
      align_buffer_16(output_0_u, ow * oh)
      align_buffer_16(output_0_v, ow * oh)
      align_buffer_16(output_270_u, ow * oh)
      align_buffer_16(output_270_v, ow * oh)
      align_buffer_16(output_180_u, ow * oh)
      align_buffer_16(output_180_v, ow * oh)

      for (i = 0; i < iw * ih; i += 2) {
        input[i] = i >> 1;
        input[i + 1] = -(i >> 1);
      }

      RotateUV270(input, iw, output_270_u, ow, output_270_v, ow,
                       iw >> 1, ih);

      RotatePlane270(output_270_u, ow, output_180_u, oh, ow, oh);
      RotatePlane270(output_270_v, ow, output_180_v, oh, ow, oh);

      RotatePlane180(output_180_u, ow, output_0_u, ow, ow, oh);
      RotatePlane180(output_180_v, ow, output_0_v, ow, ow, oh);

      for (i = 0; i < (ow * oh); ++i) {
        if (output_0_u[i] != (uint8)i) {
          err++;
        }
        if (output_0_v[i] != (uint8)(-i)) {
          err++;
        }
      }

      if (err) {
        printf("input %dx%d \n", iw, ih);
        PrintArray(input, iw, ih);

        printf("output 270_u\n");
        PrintArray(output_270_u, ow, oh);

        printf("output 270_v\n");
        PrintArray(output_270_v, ow, oh);

        printf("output 180_u\n");
        PrintArray(output_180_u, oh, ow);

        printf("output 180_v\n");
        PrintArray(output_180_v, oh, ow);

        printf("output 0_u\n");
        PrintArray(output_0_u, oh, ow);

        printf("output 0_v\n");
        PrintArray(output_0_v, oh, ow);
      }

      free_aligned_buffer_16(input)
      free_aligned_buffer_16(output_0_u)
      free_aligned_buffer_16(output_0_v)
      free_aligned_buffer_16(output_270_u)
      free_aligned_buffer_16(output_270_v)
      free_aligned_buffer_16(output_180_u)
      free_aligned_buffer_16(output_180_v)
    }
  }

  EXPECT_EQ(0, err);
}

TEST_F(libyuvTest, RotatePlane180) {
  int iw, ih, ow, oh;
  int err = 0;

  for (iw = 8; iw < rotate_max_w_ && !err; ++iw)
    for (ih = 8; ih < rotate_max_h_ && !err; ++ih) {
      int i;

      ow = iw;
      oh = ih;

      align_buffer_16(input, iw * ih)
      align_buffer_16(output_0, iw * ih)
      align_buffer_16(output_180, iw * ih)

      for (i = 0; i < iw * ih; ++i) {
        input[i] = i;
      }

      RotatePlane180(input,      iw, output_180, ow, iw, ih);
      RotatePlane180(output_180, ow, output_0,   iw, ow, oh);

      for (i = 0; i < iw * ih; ++i) {
        if (input[i] != output_0[i]) {
          err++;
        }
      }

      if (err) {
        printf("input %dx%d \n", iw, ih);
        PrintArray(input, iw, ih);

        printf("output 180\n");
        PrintArray(output_180, iw, ih);

        printf("output 0\n");
        PrintArray(output_0, iw, ih);
      }

      free_aligned_buffer_16(input)
      free_aligned_buffer_16(output_0)
      free_aligned_buffer_16(output_180)
    }

  EXPECT_EQ(0, err);
}

TEST_F(libyuvTest, RotatePlane270) {
  int iw, ih, ow, oh;
  int err = 0;

  for (iw = 8; iw < rotate_max_w_ && !err; ++iw) {
    for (ih = 8; ih < rotate_max_h_ && !err; ++ih) {
      int i;

      ow = ih;
      oh = iw;

      align_buffer_16(input, iw * ih)
      align_buffer_16(output_0, iw * ih)
      align_buffer_16(output_90, ow * oh)
      align_buffer_16(output_180, iw * ih)
      align_buffer_16(output_270, ow * oh)

      for (i = 0; i < iw * ih; ++i)
        input[i] = i;

      RotatePlane270(input,      iw, output_270, ow, iw, ih);
      RotatePlane270(output_270, ow, output_180, oh, ow, oh);
      RotatePlane270(output_180, oh, output_90,  ow, oh, ow);
      RotatePlane270(output_90,  ow, output_0,   iw, ow, oh);

      for (i = 0; i < iw * ih; ++i) {
        if (input[i] != output_0[i]) {
          err++;
        }
      }

      if (err) {
        printf("input %dx%d \n", iw, ih);
        PrintArray(input, iw, ih);

        printf("output 270\n");
        PrintArray(output_270, ow, oh);

        printf("output 180\n");
        PrintArray(output_180, iw, ih);

        printf("output 90\n");
        PrintArray(output_90, ow, oh);

        printf("output 0\n");
        PrintArray(output_0, iw, ih);
      }

      free_aligned_buffer_16(input)
      free_aligned_buffer_16(output_0)
      free_aligned_buffer_16(output_90)
      free_aligned_buffer_16(output_180)
      free_aligned_buffer_16(output_270)
    }
  }

  EXPECT_EQ(0, err);
}

TEST_F(libyuvTest, RotatePlane90and270) {
  int iw, ih, ow, oh;
  int err = 0;

  for (iw = 16; iw < rotate_max_w_ && !err; iw += 4)
    for (ih = 16; ih < rotate_max_h_ && !err; ih += 4) {
      int i;

      ow = ih;
      oh = iw;

      align_buffer_16(input, iw * ih)
      align_buffer_16(output_0, iw * ih)
      align_buffer_16(output_90, ow * oh)

      for (i = 0; i < iw * ih; ++i) {
        input[i] = i;
      }

      RotatePlane90(input,      iw, output_90,  ow, iw, ih);
      RotatePlane270(output_90, ow, output_0,   iw, ow, oh);

      for (i = 0; i < iw * ih; ++i) {
        if (input[i] != output_0[i]) {
          err++;
        }
      }

      if (err) {
        printf("intput %dx%d\n", iw, ih);
        PrintArray(input, iw, ih);

        printf("output \n");
        PrintArray(output_90, ow, oh);

        printf("output \n");
        PrintArray(output_0, iw, ih);
      }

      free_aligned_buffer_16(input)
      free_aligned_buffer_16(output_0)
      free_aligned_buffer_16(output_90)
    }

  EXPECT_EQ(0, err);
}

TEST_F(libyuvTest, RotatePlane90Pitch) {
  int iw, ih;
  int err = 0;

  for (iw = 16; iw < rotate_max_w_ && !err; iw += 4)
    for (ih = 16; ih < rotate_max_h_ && !err; ih += 4) {
      int i;

      int ow = ih;
      int oh = iw;

      align_buffer_16(input, iw * ih)
      align_buffer_16(output_0, iw * ih)
      align_buffer_16(output_90, ow * oh)

      for (i = 0; i < iw * ih; ++i) {
        input[i] = i;
      }

      RotatePlane90(input, iw,
                    output_90 + (ow >> 1), ow,
                    iw >> 1, ih >> 1);
      RotatePlane90(input + (iw >> 1), iw,
                    output_90 + (ow >> 1) + ow * (oh >> 1), ow,
                    iw >> 1, ih >> 1);
      RotatePlane90(input + iw * (ih >> 1), iw,
                    output_90, ow,
                    iw >> 1, ih >> 1);
      RotatePlane90(input + (iw >> 1) + iw * (ih >> 1), iw,
                    output_90 + ow * (oh >> 1), ow,
                    iw >> 1, ih >> 1);

      RotatePlane270(output_90, ih, output_0,   iw, ow, oh);

      for (i = 0; i < iw * ih; ++i) {
        if (input[i] != output_0[i]) {
          err++;
        }
      }

      if (err) {
        printf("intput %dx%d\n", iw, ih);
        PrintArray(input, iw, ih);

        printf("output \n");
        PrintArray(output_90, ow, oh);

        printf("output \n");
        PrintArray(output_0, iw, ih);
      }

      free_aligned_buffer_16(input)
      free_aligned_buffer_16(output_0)
      free_aligned_buffer_16(output_90)
    }

  EXPECT_EQ(0, err);
}

TEST_F(libyuvTest, RotatePlane270Pitch) {
  int iw, ih, ow, oh;
  int err = 0;

  for (iw = 16; iw < rotate_max_w_ && !err; iw += 4) {
    for (ih = 16; ih < rotate_max_h_ && !err; ih += 4) {
      int i;

      ow = ih;
      oh = iw;

      align_buffer_16(input, iw * ih)
      align_buffer_16(output_0, iw * ih)
      align_buffer_16(output_270, ow * oh)

      for (i = 0; i < iw * ih; ++i) {
        input[i] = i;
      }

      RotatePlane270(input, iw,
                     output_270 + ow * (oh >> 1), ow,
                     iw >> 1, ih >> 1);
      RotatePlane270(input + (iw >> 1), iw,
                     output_270, ow,
                     iw >> 1, ih >> 1);
      RotatePlane270(input + iw * (ih >> 1), iw,
                     output_270 + (ow >> 1) + ow * (oh >> 1), ow,
                     iw >> 1, ih >> 1);
      RotatePlane270(input + (iw >> 1) + iw * (ih >> 1), iw,
                     output_270 + (ow >> 1), ow,
                     iw >> 1, ih >> 1);

      RotatePlane90(output_270, ih, output_0,   iw, ow, oh);

      for (i = 0; i < iw * ih; ++i) {
        if (input[i] != output_0[i]) {
          err++;
        }
      }

      if (err) {
        printf("intput %dx%d\n", iw, ih);
        PrintArray(input, iw, ih);

        printf("output \n");
        PrintArray(output_270, ow, oh);

        printf("output \n");
        PrintArray(output_0, iw, ih);
      }

      free_aligned_buffer_16(input)
      free_aligned_buffer_16(output_0)
      free_aligned_buffer_16(output_270)
    }
  }

  EXPECT_EQ(0, err);
}

TEST_F(libyuvTest, I420Rotate90) {
  int err = 0;

  int yw = 1024;
  int yh = 768;
  int b = 128;
  int uvw = (yw + 1) >> 1;
  int uvh = (yh + 1) >> 1;

  int i, j;

  int y_plane_size = (yw + b * 2) * (yh + b * 2);
  int uv_plane_size = (uvw + b * 2) * (uvh + b * 2);

  srandom(time(NULL));

  align_buffer_16(orig_y, y_plane_size)
  align_buffer_16(orig_u, uv_plane_size)
  align_buffer_16(orig_v, uv_plane_size)
  align_buffer_16(ro0_y, y_plane_size)
  align_buffer_16(ro0_u, uv_plane_size)
  align_buffer_16(ro0_v, uv_plane_size)
  align_buffer_16(ro90_y, y_plane_size)
  align_buffer_16(ro90_u, uv_plane_size)
  align_buffer_16(ro90_v, uv_plane_size)
  align_buffer_16(ro270_y, y_plane_size)
  align_buffer_16(ro270_u, uv_plane_size)
  align_buffer_16(ro270_v, uv_plane_size)
  memset(orig_y, 0, y_plane_size);
  memset(orig_u, 0, uv_plane_size);
  memset(orig_v, 0, uv_plane_size);
  memset(ro0_y, 0, y_plane_size);
  memset(ro0_u, 0, uv_plane_size);
  memset(ro0_v, 0, uv_plane_size);
  memset(ro90_y, 0, y_plane_size);
  memset(ro90_u, 0, uv_plane_size);
  memset(ro90_v, 0, uv_plane_size);
  memset(ro270_y, 0, y_plane_size);
  memset(ro270_u, 0, uv_plane_size);
  memset(ro270_v, 0, uv_plane_size);

  // fill image buffers with random data
  for (i = b; i < (yh + b); ++i) {
    for (j = b; j < (yw + b); ++j) {
      orig_y[i * (yw + b * 2) + j] = random() & 0xff;
    }
  }

  for (i = b; i < (uvh + b); ++i) {
    for (j = b; j < (uvw + b); ++j) {
      orig_u[i * (uvw + b * 2) + j] = random() & 0xff;
      orig_v[i * (uvw + b * 2) + j] = random() & 0xff;
    }
  }

  int y_off_0 = b * (yw + b * 2) + b;
  int uv_off_0 = b * (uvw + b * 2) + b;
  int y_off_90 = b * (yh + b * 2) + b;
  int uv_off_90 = b * (uvh + b * 2) + b;

  int y_st_0 = yw + b * 2;
  int uv_st_0 = uvw + b * 2;
  int y_st_90 = yh + b * 2;
  int uv_st_90 = uvh + b * 2;

  I420Rotate(orig_y+y_off_0, y_st_0,
             orig_u+uv_off_0, uv_st_0,
             orig_v+uv_off_0, uv_st_0,
             ro90_y+y_off_90, y_st_90,
             ro90_u+uv_off_90, uv_st_90,
             ro90_v+uv_off_90, uv_st_90,
             yw, yh,
             kRotateClockwise);

  I420Rotate(ro90_y+y_off_90, y_st_90,
             ro90_u+uv_off_90, uv_st_90,
             ro90_v+uv_off_90, uv_st_90,
             ro270_y+y_off_90, y_st_90,
             ro270_u+uv_off_90, uv_st_90,
             ro270_v+uv_off_90, uv_st_90,
             yh, yw,
             kRotate180);

  I420Rotate(ro270_y+y_off_90, y_st_90,
             ro270_u+uv_off_90, uv_st_90,
             ro270_v+uv_off_90, uv_st_90,
             ro0_y+y_off_0, y_st_0,
             ro0_u+uv_off_0, uv_st_0,
             ro0_v+uv_off_0, uv_st_0,
             yh, yw,
             kRotateClockwise);

  for (i = 0; i < y_plane_size; ++i) {
    if (orig_y[i] != ro0_y[i]) {
      ++err;
    }
  }

  for (i = 0; i < uv_plane_size; ++i) {
    if (orig_u[i] != ro0_u[i]) {
      ++err;
    }
    if (orig_v[i] != ro0_v[i]) {
      ++err;
    }
  }

  free_aligned_buffer_16(orig_y)
  free_aligned_buffer_16(orig_u)
  free_aligned_buffer_16(orig_v)
  free_aligned_buffer_16(ro0_y)
  free_aligned_buffer_16(ro0_u)
  free_aligned_buffer_16(ro0_v)
  free_aligned_buffer_16(ro90_y)
  free_aligned_buffer_16(ro90_u)
  free_aligned_buffer_16(ro90_v)
  free_aligned_buffer_16(ro270_y)
  free_aligned_buffer_16(ro270_u)
  free_aligned_buffer_16(ro270_v)

  EXPECT_EQ(0, err);
}

TEST_F(libyuvTest, I420Rotate270) {
  int err = 0;

  int yw = 1024;
  int yh = 768;
  int b = 128;
  int uvw = (yw + 1) >> 1;
  int uvh = (yh + 1) >> 1;

  int i, j;

  int y_plane_size = (yw + b * 2) * (yh + b * 2);
  int uv_plane_size = (uvw + b * 2) * (uvh + b * 2);

  srandom(time(NULL));

  align_buffer_16(orig_y, y_plane_size)
  align_buffer_16(orig_u, uv_plane_size)
  align_buffer_16(orig_v, uv_plane_size)
  align_buffer_16(ro0_y, y_plane_size)
  align_buffer_16(ro0_u, uv_plane_size)
  align_buffer_16(ro0_v, uv_plane_size)
  align_buffer_16(ro90_y, y_plane_size)
  align_buffer_16(ro90_u, uv_plane_size)
  align_buffer_16(ro90_v, uv_plane_size)
  align_buffer_16(ro270_y, y_plane_size)
  align_buffer_16(ro270_u, uv_plane_size)
  align_buffer_16(ro270_v, uv_plane_size)
  memset(orig_y, 0, y_plane_size);
  memset(orig_u, 0, uv_plane_size);
  memset(orig_v, 0, uv_plane_size);
  memset(ro0_y, 0, y_plane_size);
  memset(ro0_u, 0, uv_plane_size);
  memset(ro0_v, 0, uv_plane_size);
  memset(ro90_y, 0, y_plane_size);
  memset(ro90_u, 0, uv_plane_size);
  memset(ro90_v, 0, uv_plane_size);
  memset(ro270_y, 0, y_plane_size);
  memset(ro270_u, 0, uv_plane_size);
  memset(ro270_v, 0, uv_plane_size);

  // fill image buffers with random data
  for (i = b; i < (yh + b); ++i) {
    for (j = b; j < (yw + b); ++j) {
      orig_y[i * (yw + b * 2) + j] = random() & 0xff;
    }
  }

  for (i = b; i < (uvh + b); ++i) {
    for (j = b; j < (uvw + b); ++j) {
      orig_u[i * (uvw + b * 2) + j] = random() & 0xff;
      orig_v[i * (uvw + b * 2) + j] = random() & 0xff;
    }
  }

  int y_off_0 = b * (yw + b * 2) + b;
  int uv_off_0 = b * (uvw + b * 2) + b;
  int y_off_90 = b * (yh + b * 2) + b;
  int uv_off_90 = b * (uvh + b * 2) + b;

  int y_st_0 = yw + b * 2;
  int uv_st_0 = uvw + b * 2;
  int y_st_90 = yh + b * 2;
  int uv_st_90 = uvh + b * 2;

  I420Rotate(orig_y+y_off_0, y_st_0,
             orig_u+uv_off_0, uv_st_0,
             orig_v+uv_off_0, uv_st_0,
             ro270_y+y_off_90, y_st_90,
             ro270_u+uv_off_90, uv_st_90,
             ro270_v+uv_off_90, uv_st_90,
             yw, yh,
             kRotateCounterClockwise);

  I420Rotate(ro270_y+y_off_90, y_st_90,
             ro270_u+uv_off_90, uv_st_90,
             ro270_v+uv_off_90, uv_st_90,
             ro90_y+y_off_90, y_st_90,
             ro90_u+uv_off_90, uv_st_90,
             ro90_v+uv_off_90, uv_st_90,
             yh, yw,
             kRotate180);

  I420Rotate(ro90_y+y_off_90, y_st_90,
             ro90_u+uv_off_90, uv_st_90,
             ro90_v+uv_off_90, uv_st_90,
             ro0_y+y_off_0, y_st_0,
             ro0_u+uv_off_0, uv_st_0,
             ro0_v+uv_off_0, uv_st_0,
             yh, yw,
             kRotateCounterClockwise);

  for (i = 0; i < y_plane_size; ++i) {
    if (orig_y[i] != ro0_y[i]) {
      ++err;
    }
  }

  for (i = 0; i < uv_plane_size; ++i) {
    if (orig_u[i] != ro0_u[i]) {
      ++err;
    }
    if (orig_v[i] != ro0_v[i]) {
      ++err;
    }
  }

  free_aligned_buffer_16(orig_y)
  free_aligned_buffer_16(orig_u)
  free_aligned_buffer_16(orig_v)
  free_aligned_buffer_16(ro0_y)
  free_aligned_buffer_16(ro0_u)
  free_aligned_buffer_16(ro0_v)
  free_aligned_buffer_16(ro90_y)
  free_aligned_buffer_16(ro90_u)
  free_aligned_buffer_16(ro90_v)
  free_aligned_buffer_16(ro270_y)
  free_aligned_buffer_16(ro270_u)
  free_aligned_buffer_16(ro270_v)

  EXPECT_EQ(0, err);
}

TEST_F(libyuvTest, NV12ToI420Rotate90) {
  int err = 0;

  int yw = 1024;
  int yh = 768;
  int b = 128;
  int uvw = (yw + 1) >> 1;
  int uvh = (yh + 1) >> 1;
  int i, j;

  int y_plane_size = (yw + b * 2) * (yh + b * 2);
  int uv_plane_size = (uvw + b * 2) * (uvh + b * 2);
  int o_uv_plane_size = (uvw * 2 + b * 2) * (uvh + b * 2);

  srandom(time(NULL));

  align_buffer_16(orig_y, y_plane_size)
  align_buffer_16(orig_uv, o_uv_plane_size)
  align_buffer_16(ro0_y, y_plane_size)
  align_buffer_16(ro0_u, uv_plane_size)
  align_buffer_16(ro0_v, uv_plane_size)
  align_buffer_16(ro90_y, y_plane_size)
  align_buffer_16(ro90_u, uv_plane_size)
  align_buffer_16(ro90_v, uv_plane_size)
  memset(orig_y, 0, y_plane_size);
  memset(orig_uv, 0, uv_plane_size);
  memset(ro0_y, 0, y_plane_size);
  memset(ro0_u, 0, uv_plane_size);
  memset(ro0_v, 0, uv_plane_size);
  memset(ro90_y, 0, y_plane_size);
  memset(ro90_u, 0, uv_plane_size);
  memset(ro90_v, 0, uv_plane_size);

  // fill image buffers with random data
  for (i = b; i < (yh + b); ++i) {
    for (j = b; j < (yw + b); ++j) {
      orig_y[i * (yw + b * 2) + j] = random() & 0xff;
    }
  }

  for (i = b; i < (uvh + b); ++i) {
    for (j = b; j < (uvw * 2 + b); j += 2) {
      uint8 random_number = random() & 0x7f;
      orig_uv[i * (uvw * 2 + b * 2) + j] = random_number;
      orig_uv[i * (uvw * 2 + b * 2) + j + 1] = -random_number;
    }
  }

  int y_off_0 = b * (yw + b * 2) + b;
  int uv_off_0 = b * (uvw + b * 2) + b;
  int y_off_90 = b * (yh + b * 2) + b;
  int uv_off_90 = b * (uvh + b * 2) + b;

  int y_st_0 = yw + b * 2;
  int uv_st_0 = uvw + b * 2;
  int y_st_90 = yh + b * 2;
  int uv_st_90 = uvh + b * 2;

  NV12ToI420Rotate(orig_y+y_off_0, y_st_0,
                   orig_uv+y_off_0, y_st_0,
                   ro90_y+y_off_90, y_st_90,
                   ro90_u+uv_off_90, uv_st_90,
                   ro90_v+uv_off_90, uv_st_90,
                   yw, yh,
                   kRotateClockwise);

  I420Rotate(ro90_y+y_off_90, y_st_90,
             ro90_u+uv_off_90, uv_st_90,
             ro90_v+uv_off_90, uv_st_90,
             ro0_y+y_off_0, y_st_0,
             ro0_u+uv_off_0, uv_st_0,
             ro0_v+uv_off_0, uv_st_0,
             yh, yw,
             kRotateCounterClockwise);

  for (i = 0; i < y_plane_size; ++i) {
    if (orig_y[i] != ro0_y[i])
      ++err;
  }

  int zero_cnt = 0;

  for (i = 0; i < uv_plane_size; ++i) {
    if ((signed char)ro0_u[i] != -(signed char)ro0_v[i]) {
      ++err;
    }
    if (ro0_u[i] != 0) {
      ++zero_cnt;
    }
  }

  if (!zero_cnt) {
    ++err;
  }

  free_aligned_buffer_16(orig_y)
  free_aligned_buffer_16(orig_uv)
  free_aligned_buffer_16(ro0_y)
  free_aligned_buffer_16(ro0_u)
  free_aligned_buffer_16(ro0_v)
  free_aligned_buffer_16(ro90_y)
  free_aligned_buffer_16(ro90_u)
  free_aligned_buffer_16(ro90_v)

  EXPECT_EQ(0, err);
}

TEST_F(libyuvTest, NV12ToI420Rotate270) {
  int err = 0;

  int yw = 1024;
  int yh = 768;
  int b = 128;
  int uvw = (yw + 1) >> 1;
  int uvh = (yh + 1) >> 1;

  int i, j;

  int y_plane_size = (yw + b * 2) * (yh + b * 2);
  int uv_plane_size = (uvw + b * 2) * (uvh + b * 2);
  int o_uv_plane_size = (uvw * 2 + b * 2) * (uvh + b * 2);

  srandom(time(NULL));

  align_buffer_16(orig_y, y_plane_size)
  align_buffer_16(orig_uv, o_uv_plane_size)
  align_buffer_16(ro0_y, y_plane_size)
  align_buffer_16(ro0_u, uv_plane_size)
  align_buffer_16(ro0_v, uv_plane_size)
  align_buffer_16(ro270_y, y_plane_size)
  align_buffer_16(ro270_u, uv_plane_size)
  align_buffer_16(ro270_v, uv_plane_size)
  memset(orig_y, 0, y_plane_size);
  memset(orig_uv, 0, o_uv_plane_size);
  memset(ro0_y, 0, y_plane_size);
  memset(ro0_u, 0, uv_plane_size);
  memset(ro0_v, 0, uv_plane_size);
  memset(ro270_y, 0, y_plane_size);
  memset(ro270_u, 0, uv_plane_size);
  memset(ro270_v, 0, uv_plane_size);

  // fill image buffers with random data
  for (i = b; i < (yh + b); ++i) {
    for (j = b; j < (yw + b); ++j) {
      orig_y[i * (yw + b * 2) + j] = random() & 0xff;
    }
  }

  for (i = b; i < (uvh + b); ++i) {
    for (j = b; j < (uvw * 2 + b); j += 2) {
      uint8 random_number = random() & 0x7f;
      orig_uv[i * (uvw * 2 + b * 2) + j] = random_number;
      orig_uv[i * (uvw * 2 + b * 2) + j + 1] = -random_number;
    }
  }

  int y_off_0 = b * (yw + b * 2) + b;
  int uv_off_0 = b * (uvw + b * 2) + b;
  int y_off_270 = b * (yh + b * 2) + b;
  int uv_off_270 = b * (uvh + b * 2) + b;

  int y_st_0 = yw + b * 2;
  int uv_st_0 = uvw + b * 2;
  int y_st_270 = yh + b * 2;
  int uv_st_270 = uvh + b * 2;

  NV12ToI420Rotate(orig_y+y_off_0, y_st_0,
                   orig_uv+y_off_0, y_st_0,
                   ro270_y+y_off_270, y_st_270,
                   ro270_u+uv_off_270, uv_st_270,
                   ro270_v+uv_off_270, uv_st_270,
                   yw, yh,
                   kRotateCounterClockwise);

  I420Rotate(ro270_y+y_off_270, y_st_270,
             ro270_u+uv_off_270, uv_st_270,
             ro270_v+uv_off_270, uv_st_270,
             ro0_y+y_off_0, y_st_0,
             ro0_u+uv_off_0, uv_st_0,
             ro0_v+uv_off_0, uv_st_0,
             yh, yw,
             kRotateClockwise);

  for (i = 0; i < y_plane_size; ++i) {
    if (orig_y[i] != ro0_y[i])
      ++err;
  }

  int zero_cnt = 0;

  for (i = 0; i < uv_plane_size; ++i) {
    if ((signed char)ro0_u[i] != -(signed char)ro0_v[i]) {
      ++err;
    }
    if (ro0_u[i] != 0) {
      ++zero_cnt;
    }
  }

  if (!zero_cnt) {
    ++err;
  }

  free_aligned_buffer_16(orig_y)
  free_aligned_buffer_16(orig_uv)
  free_aligned_buffer_16(ro0_y)
  free_aligned_buffer_16(ro0_u)
  free_aligned_buffer_16(ro0_v)
  free_aligned_buffer_16(ro270_y)
  free_aligned_buffer_16(ro270_u)
  free_aligned_buffer_16(ro270_v)

  EXPECT_EQ(0, err);
}

TEST_F(libyuvTest, NV12ToI420Rotate180) {
  int err = 0;

  int yw = 1024;
  int yh = 768;
  int b = 128;
  int uvw = (yw + 1) >> 1;
  int uvh = (yh + 1) >> 1;

  int i, j;

  int y_plane_size = (yw + b * 2) * (yh + b * 2);
  int uv_plane_size = (uvw + b * 2) * (uvh + b * 2);
  int o_uv_plane_size = (uvw * 2 + b * 2) * (uvh + b * 2);

  srandom(time(NULL));

  align_buffer_16(orig_y, y_plane_size)
  align_buffer_16(orig_uv, o_uv_plane_size)
  align_buffer_16(ro0_y, y_plane_size)
  align_buffer_16(ro0_u, uv_plane_size)
  align_buffer_16(ro0_v, uv_plane_size)
  align_buffer_16(ro180_y, y_plane_size)
  align_buffer_16(ro180_u, uv_plane_size)
  align_buffer_16(ro180_v, uv_plane_size)
  memset(orig_y, 0, y_plane_size);
  memset(orig_uv, 0, o_uv_plane_size);
  memset(ro0_y, 0, y_plane_size);
  memset(ro0_u, 0, uv_plane_size);
  memset(ro0_v, 0, uv_plane_size);
  memset(ro180_y, 0, y_plane_size);
  memset(ro180_u, 0, uv_plane_size);
  memset(ro180_v, 0, uv_plane_size);

  // fill image buffers with random data
  for (i = b; i < (yh + b); ++i) {
    for (j = b; j < (yw + b); ++j) {
      orig_y[i * (yw + b * 2) + j] = random() & 0xff;
    }
  }

  for (i = b; i < (uvh + b); ++i) {
    for (j = b; j < (uvw * 2 + b); j += 2) {
      uint8 random_number = random() & 0x7f;
      orig_uv[i * (uvw * 2 + b * 2) + j] = random_number;
      orig_uv[i * (uvw * 2 + b * 2) + j + 1] = -random_number;
    }
  }

  int y_off = b * (yw + b * 2) + b;
  int uv_off = b * (uvw + b * 2) + b;

  int y_st = yw + b * 2;
  int uv_st = uvw + b * 2;

  NV12ToI420Rotate(orig_y+y_off, y_st,
                   orig_uv+y_off, y_st,
                   ro180_y+y_off, y_st,
                   ro180_u+uv_off, uv_st,
                   ro180_v+uv_off, uv_st,
                   yw, yh,
                   kRotate180);

  I420Rotate(ro180_y+y_off, y_st,
             ro180_u+uv_off, uv_st,
             ro180_v+uv_off, uv_st,
             ro0_y+y_off, y_st,
             ro0_u+uv_off, uv_st,
             ro0_v+uv_off, uv_st,
             yw, yh,
             kRotate180);

  for (i = 0; i < y_plane_size; ++i) {
    if (orig_y[i] != ro0_y[i]) {
      ++err;
    }
  }

  int zero_cnt = 0;

  for (i = 0; i < uv_plane_size; ++i) {
    if ((signed char)ro0_u[i] != -(signed char)ro0_v[i]) {
      ++err;
    }
    if (ro0_u[i] != 0) {
      ++zero_cnt;
    }
  }

  if (!zero_cnt) {
    ++err;
  }

  free_aligned_buffer_16(orig_y)
  free_aligned_buffer_16(orig_uv)
  free_aligned_buffer_16(ro0_y)
  free_aligned_buffer_16(ro0_u)
  free_aligned_buffer_16(ro0_v)
  free_aligned_buffer_16(ro180_y)
  free_aligned_buffer_16(ro180_u)
  free_aligned_buffer_16(ro180_v)

  EXPECT_EQ(0, err);
}

TEST_F(libyuvTest, NV12ToI420RotateNegHeight90) {
  int y_err = 0, uv_err = 0;

  int yw = 1024;
  int yh = 768;
  int b = 128;
  int uvw = (yw + 1) >> 1;
  int uvh = (yh + 1) >> 1;
  int i, j;

  int y_plane_size = (yw + b * 2) * (yh + b * 2);
  int uv_plane_size = (uvw + b * 2) * (uvh + b * 2);
  int o_uv_plane_size = (uvw * 2 + b * 2) * (uvh + b * 2);

  srandom(time(NULL));

  align_buffer_16(orig_y, y_plane_size)
  align_buffer_16(orig_uv, o_uv_plane_size)
  align_buffer_16(roa_y, y_plane_size)
  align_buffer_16(roa_u, uv_plane_size)
  align_buffer_16(roa_v, uv_plane_size)
  align_buffer_16(rob_y, y_plane_size)
  align_buffer_16(rob_u, uv_plane_size)
  align_buffer_16(rob_v, uv_plane_size)
  align_buffer_16(roc_y, y_plane_size)
  align_buffer_16(roc_u, uv_plane_size)
  align_buffer_16(roc_v, uv_plane_size)
  memset(orig_y, 0, y_plane_size);
  memset(orig_uv, 0, o_uv_plane_size);
  memset(roa_y, 0, y_plane_size);
  memset(roa_u, 0, uv_plane_size);
  memset(roa_v, 0, uv_plane_size);
  memset(rob_y, 0, y_plane_size);
  memset(rob_u, 0, uv_plane_size);
  memset(rob_v, 0, uv_plane_size);
  memset(roc_y, 0, y_plane_size);
  memset(roc_u, 0, uv_plane_size);
  memset(roc_v, 0, uv_plane_size);

  // fill image buffers with random data
  for (i = b; i < (yh + b); ++i) {
    for (j = b; j < (yw + b); ++j) {
      orig_y[i * (yw + b * 2) + j] = random() & 0xff;
    }
  }

  for (i = b; i < (uvh + b); ++i) {
    for (j = b; j < (uvw * 2 + b); j += 2) {
      uint8 random_number = random() & 0x7f;
      orig_uv[i * (uvw * 2 + b * 2) + j] = random_number;
      orig_uv[i * (uvw * 2 + b * 2) + j + 1] = -random_number;
    }
  }

  int y_off_0 = b * (yw + b * 2) + b;
  int uv_off_0 = b * (uvw + b * 2) + b;
  int y_off_90 = b * (yh + b * 2) + b;
  int uv_off_90 = b * (uvh + b * 2) + b;

  int y_st_0 = yw + b * 2;
  int uv_st_0 = uvw + b * 2;
  int y_st_90 = yh + b * 2;
  int uv_st_90 = uvh + b * 2;

  NV12ToI420Rotate(orig_y+y_off_0, y_st_0,
                   orig_uv+y_off_0, y_st_0,
                   roa_y+y_off_90, y_st_90,
                   roa_u+uv_off_90, uv_st_90,
                   roa_v+uv_off_90, uv_st_90,
                   yw, -yh,
                   kRotateClockwise);

  I420Rotate(roa_y+y_off_90, y_st_90,
             roa_u+uv_off_90, uv_st_90,
             roa_v+uv_off_90, uv_st_90,
             rob_y+y_off_0, y_st_0,
             rob_u+uv_off_0, uv_st_0,
             rob_v+uv_off_0, uv_st_0,
             yh, -yw,
             kRotateCounterClockwise);

  I420Rotate(rob_y+y_off_0, y_st_0,
             rob_u+uv_off_0, uv_st_0,
             rob_v+uv_off_0, uv_st_0,
             roc_y+y_off_0, y_st_0,
             roc_u+uv_off_0, uv_st_0,
             roc_v+uv_off_0, uv_st_0,
             yw, yh,
             kRotate180);

  for (i = 0; i < y_plane_size; ++i) {
    if (orig_y[i] != roc_y[i]) {
      ++y_err;
    }
  }

  if (y_err) {
    printf("input %dx%d \n", yw, yh);
    PrintArray(orig_y, y_st_0, yh + b * 2);

    printf("rotate a\n");
    PrintArray(roa_y, y_st_90, y_st_0);

    printf("rotate b\n");
    PrintArray(rob_y, y_st_90, y_st_0);

    printf("rotate c\n");
    PrintArray(roc_y, y_st_0, y_st_90);
  }

  int zero_cnt = 0;

  for (i = 0; i < uv_plane_size; ++i) {
    if ((signed char)roc_u[i] != -(signed char)roc_v[i]) {
      ++uv_err;
    }
    if (rob_u[i] != 0) {
      ++zero_cnt;
    }
  }

  if (!zero_cnt) {
    ++uv_err;
  }

  if (uv_err) {
    printf("input %dx%d \n", uvw * 2, uvh);
    PrintArray(orig_uv, y_st_0, uvh + b * 2);

    printf("rotate a\n");
    PrintArray(roa_u, uv_st_90, uv_st_0);
    PrintArray(roa_v, uv_st_90, uv_st_0);

    printf("rotate b\n");
    PrintArray(rob_u, uv_st_90, uv_st_0);
    PrintArray(rob_v, uv_st_90, uv_st_0);

    printf("rotate c\n");
    PrintArray(roc_u, uv_st_0, uv_st_90);
    PrintArray(roc_v, uv_st_0, uv_st_90);
  }

  free_aligned_buffer_16(orig_y)
  free_aligned_buffer_16(orig_uv)
  free_aligned_buffer_16(roa_y)
  free_aligned_buffer_16(roa_u)
  free_aligned_buffer_16(roa_v)
  free_aligned_buffer_16(rob_y)
  free_aligned_buffer_16(rob_u)
  free_aligned_buffer_16(rob_v)
  free_aligned_buffer_16(roc_y)
  free_aligned_buffer_16(roc_u)
  free_aligned_buffer_16(roc_v)

  EXPECT_EQ(0, y_err + uv_err);
}

TEST_F(libyuvTest, NV12ToI420RotateNegHeight180) {
  int y_err = 0, uv_err = 0;

  int yw = 1024;
  int yh = 768;
  int b = 128;
  int uvw = (yw + 1) >> 1;
  int uvh = (yh + 1) >> 1;
  int i, j;

  int y_plane_size = (yw + b * 2) * (yh + b * 2);
  int uv_plane_size = (uvw + b * 2) * (uvh + b * 2);
  int o_uv_plane_size = (uvw * 2 + b * 2) * (uvh + b * 2);

  srandom(time(NULL));

  align_buffer_16(orig_y, y_plane_size)
  align_buffer_16(orig_uv, o_uv_plane_size)
  align_buffer_16(roa_y, y_plane_size)
  align_buffer_16(roa_u, uv_plane_size)
  align_buffer_16(roa_v, uv_plane_size)
  align_buffer_16(rob_y, y_plane_size)
  align_buffer_16(rob_u, uv_plane_size)
  align_buffer_16(rob_v, uv_plane_size)
  memset(orig_y, 0, y_plane_size);
  memset(orig_uv, 0, o_uv_plane_size);
  memset(roa_y, 0, y_plane_size);
  memset(roa_u, 0, uv_plane_size);
  memset(roa_v, 0, uv_plane_size);
  memset(rob_y, 0, y_plane_size);
  memset(rob_u, 0, uv_plane_size);
  memset(rob_v, 0, uv_plane_size);

  // fill image buffers with random data
  for (i = b; i < (yh + b); ++i) {
    for (j = b; j < (yw + b); ++j) {
      orig_y[i * (yw + b * 2) + j] = random() & 0xff;
    }
  }

  for (i = b; i < (uvh + b); ++i) {
    for (j = b; j < (uvw * 2 + b); j += 2) {
      uint8 random_number = random() & 0x7f;
      orig_uv[i * (uvw * 2 + b * 2) + j] = random_number;
      orig_uv[i * (uvw * 2 + b * 2) + j + 1] = -random_number;
    }
  }

  int y_off = b * (yw + b * 2) + b;
  int uv_off = b * (uvw + b * 2) + b;

  int y_st = yw + b * 2;
  int uv_st = uvw + b * 2;

  NV12ToI420Rotate(orig_y+y_off, y_st,
                   orig_uv+y_off, y_st,
                   roa_y+y_off, y_st,
                   roa_u+uv_off, uv_st,
                   roa_v+uv_off, uv_st,
                   yw, -yh,
                   kRotate180);

  I420Rotate(roa_y+y_off, y_st,
             roa_u+uv_off, uv_st,
             roa_v+uv_off, uv_st,
             rob_y+y_off, y_st,
             rob_u+uv_off, uv_st,
             rob_v+uv_off, uv_st,
             yw, -yh,
             kRotate180);

  for (i = 0; i < y_plane_size; ++i) {
    if (orig_y[i] != rob_y[i])
      ++y_err;
  }

  if (y_err) {
    printf("input %dx%d \n", yw, yh);
    PrintArray(orig_y, y_st, yh + b * 2);

    printf("rotate a\n");
    PrintArray(roa_y, y_st, yh + b * 2);

    printf("rotate b\n");
    PrintArray(rob_y, y_st, yh + b * 2);
  }

  int zero_cnt = 0;

  for (i = 0; i < uv_plane_size; ++i) {
    if ((signed char)rob_u[i] != -(signed char)rob_v[i]) {
      ++uv_err;
    }
    if (rob_u[i] != 0) {
      ++zero_cnt;
    }
  }

  if (!zero_cnt) {
    ++uv_err;
  }

  if (uv_err) {
    printf("input %dx%d \n", uvw * 2, uvh);
    PrintArray(orig_uv, y_st, uvh + b * 2);

    printf("rotate a\n");
    PrintArray(roa_u, uv_st, uvh + b * 2);
    PrintArray(roa_v, uv_st, uvh + b * 2);

    printf("rotate b\n");
    PrintArray(rob_u, uv_st, uvh + b * 2);
    PrintArray(rob_v, uv_st, uvh + b * 2);
  }

  free_aligned_buffer_16(orig_y)
  free_aligned_buffer_16(orig_uv)
  free_aligned_buffer_16(roa_y)
  free_aligned_buffer_16(roa_u)
  free_aligned_buffer_16(roa_v)
  free_aligned_buffer_16(rob_y)
  free_aligned_buffer_16(rob_u)
  free_aligned_buffer_16(rob_v)

  EXPECT_EQ(0, y_err + uv_err);
}

}  // namespace libyuv