/*
 *  Copyright (c) 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/general.h"

#include <string.h>     // memcpy(), memset()

#include "libyuv/planar_functions.h"

namespace libyuv {

int
I420Mirror(const uint8* src_yplane, int src_ystride,
           const uint8* src_uplane, int src_ustride,
           const uint8* src_vplane, int src_vstride,
           uint8* dst_yplane, int dst_ystride,
           uint8* dst_uplane, int dst_ustride,
           uint8* dst_vplane, int dst_vstride,
           int width, int height) {
  if (src_yplane == NULL || src_uplane == NULL || src_vplane == NULL ||
      dst_yplane == NULL || dst_uplane == NULL || dst_vplane == NULL) {
    return -1;
  }

  int indO = 0;
  int indS  = 0;
  int wind, hind;
  uint8 tmpVal, tmpValU, tmpValV;
  // Will swap two values per iteration
  const int halfWidth = (width + 1) >> 1;

  // Y
  for (wind = 0; wind < halfWidth; wind++) {
   for (hind = 0; hind < height; hind++) {
     indO = hind * src_ystride + wind;
     indS = hind * dst_ystride + (width - wind - 1);
     tmpVal = src_yplane[indO];
     dst_yplane[indO] = src_yplane[indS];
     dst_yplane[indS] = tmpVal;
    }
  }

  const int halfHeight = (height + 1) >> 1;
  const int halfSrcuvStride = (height + 1) >> 1;
  const int halfuvWidth = (width + 1) >> 2;

  for (wind = 0; wind < halfuvWidth; wind++) {
   for (hind = 0; hind < halfHeight; hind++) {
     indO = hind * halfSrcuvStride + wind;
     indS = hind * halfSrcuvStride + (halfuvWidth - wind - 1);
     // U
     tmpValU = src_uplane[indO];
     dst_uplane[indO] = src_uplane[indS];
     dst_uplane[indS] = tmpValU;
     // V
     tmpValV = src_vplane[indO];
     dst_vplane[indO] = src_vplane[indS];
     dst_vplane[indS] = tmpValV;
   }
  }
  return 0;
}

// Make a center cut
int
I420Crop(uint8* frame,
         int src_width, int src_height,
         int dst_width, int dst_height)
{
  if (frame == NULL)
    return -1;

  if (src_width == dst_width && src_height == dst_height) {
      // Nothing to do
    return 3 * dst_height * dst_width / 2;
  }
  if (dst_width > src_width || dst_height > src_height) {
      // error
      return -1;
  }
  int i = 0;
  int m = 0;
  int loop = 0;
  int half_dst_width = dst_width / 2;
  int halfdst_height = dst_height / 2;
  int halfsrc_width = src_width / 2;
  int half_dst_height= src_height / 2;
  int crop_height = ( src_height - dst_height ) / 2;
  int crop_width = ( src_width - dst_width ) / 2;

  for (i = src_width * crop_height + crop_width; loop < dst_height ;
      loop++, i += src_width) {
    memcpy(&frame[m],&frame[i],dst_width);
    m += dst_width;
  }
  i = src_width * src_height; // ilum
  loop = 0;
  for ( i += (halfsrc_width * crop_height / 2 + crop_width / 2);
        loop < halfdst_height; loop++,i += halfsrc_width) {
    memcpy(&frame[m],&frame[i],half_dst_width);
    m += half_dst_width;
  }
  loop = 0;
  i = src_width * src_height + half_dst_height * halfsrc_width; // ilum + Cr
  for ( i += (halfsrc_width * crop_height / 2 + crop_width / 2);
        loop < halfdst_height; loop++, i += halfsrc_width) {
    memcpy(&frame[m],&frame[i],half_dst_width);
    m += half_dst_width;
  }
  return 0;
}


int
I420CropPad(const uint8* src_frame, int src_width,
            int src_height, uint8* dst_frame,
            int dst_width, int dst_height)
{
  if (src_width < 1 || dst_width < 1 || src_height < 1 || dst_height < 1) {
    return -1;
  }
  if (src_width == dst_width && src_height == dst_height) {
    memcpy(dst_frame, src_frame, 3 * dst_width * (dst_height >> 1));
  } else {
    if (src_height < dst_height) {
      // pad height
      int pad_height = dst_height - src_height;
      int i = 0;
      int pad_width = 0;
      int crop_width = 0;
      int width = src_width;
      if (src_width < dst_width) {
        // pad width
        pad_width = dst_width - src_width;
      } else {
        // cut width
        crop_width = src_width - dst_width;
        width = dst_width;
      }
      if (pad_height) {
        memset(dst_frame, 0, dst_width * (pad_height >> 1));
        dst_frame +=  dst_width * (pad_height >> 1);
      }
      for (i = 0; i < src_height;i++) {
        if (pad_width) {
            memset(dst_frame, 0, pad_width / 2);
            dst_frame +=  pad_width / 2;
        }
        src_frame += crop_width >> 1; // in case we have a cut
        memcpy(dst_frame,src_frame ,width);
        src_frame += crop_width >> 1;
        dst_frame += width;
        src_frame += width;
        if (pad_width) {
          memset(dst_frame, 0, pad_width / 2);
          dst_frame +=  pad_width / 2;
        }
      }
      if (pad_height) {
        memset(dst_frame, 0, dst_width * (pad_height >> 1));
        dst_frame +=  dst_width * (pad_height >> 1);
      }
      if (pad_height) {
        memset(dst_frame, 127, (dst_width >> 2) * (pad_height >> 1));
        dst_frame +=  (dst_width >> 2) * (pad_height >> 1);
      }
      for (i = 0; i < (src_height >> 1); i++) {
        if (pad_width) {
          memset(dst_frame, 127, pad_width >> 2);
          dst_frame +=  pad_width >> 2;
        }
        src_frame += crop_width >> 2; // in case we have a cut
        memcpy(dst_frame, src_frame,width >> 1);
        src_frame += crop_width >> 2;
        dst_frame += width >> 1;
        src_frame += width >> 1;
        if (pad_width) {
          memset(dst_frame, 127, pad_width >> 2);
          dst_frame +=  pad_width >> 2;
        }
      }
      if (pad_height) {
        memset(dst_frame, 127, (dst_width >> 1) * (pad_height >> 1));
        dst_frame +=  (dst_width >> 1) * (pad_height >> 1);
      }
      for (i = 0; i < (src_height >> 1); i++) {
        if (pad_width) {
          memset(dst_frame, 127, pad_width >> 2);
          dst_frame +=  pad_width >> 2;
        }
        src_frame += crop_width >> 2; // in case we have a cut
        memcpy(dst_frame, src_frame,width >> 1);
        src_frame += crop_width >> 2;
        dst_frame += width >> 1;
        src_frame += width >> 1;
        if (pad_width) {
          memset(dst_frame, 127, pad_width >> 2);
          dst_frame += pad_width >> 2;
        }
      }
      if (pad_height) {
        memset(dst_frame, 127, (dst_width >> 2) * (pad_height >> 1));
        dst_frame +=  (dst_width >> 2) * (pad_height >> 1);
      }
    } else {
      // cut height
      int i = 0;
      int pad_width = 0;
      int crop_width = 0;
      int width = src_width;

      if (src_width < dst_width) {
        // pad width
        pad_width = dst_width - src_width;
      } else {
        // cut width
        crop_width = src_width - dst_width;
        width = dst_width;
      }
      int diff_height = src_height - dst_height;
      src_frame += src_width * (diff_height >> 1);  // skip top I

      for (i = 0; i < dst_height; i++) {
        if (pad_width) {
          memset(dst_frame, 0, pad_width / 2);
          dst_frame +=  pad_width / 2;
        }
        src_frame += crop_width >> 1; // in case we have a cut
        memcpy(dst_frame,src_frame ,width);
        src_frame += crop_width >> 1;
        dst_frame += width;
        src_frame += width;
        if (pad_width) {
          memset(dst_frame, 0, pad_width / 2);
          dst_frame +=  pad_width / 2;
        }
      }
      src_frame += src_width * (diff_height >> 1);  // skip end I
      src_frame += (src_width >> 2) * (diff_height >> 1); // skip top of Cr
      for (i = 0; i < (dst_height >> 1); i++) {
        if (pad_width) {
          memset(dst_frame, 127, pad_width >> 2);
          dst_frame +=  pad_width >> 2;
        }
        src_frame += crop_width >> 2; // in case we have a cut
        memcpy(dst_frame, src_frame,width >> 1);
        src_frame += crop_width >> 2;
        dst_frame += width >> 1;
        src_frame += width >> 1;
        if (pad_width) {
          memset(dst_frame, 127, pad_width >> 2);
          dst_frame +=  pad_width >> 2;
        }
      }
      src_frame += (src_width >> 2) * (diff_height >> 1); // skip end of Cr
      src_frame += (src_width >> 2) * (diff_height >> 1); // skip top of Cb
      for (i = 0; i < (dst_height >> 1); i++) {
        if (pad_width) {
          memset(dst_frame, 127, pad_width >> 2);
          dst_frame +=  pad_width >> 2;
        }
        src_frame += crop_width >> 2; // in case we have a cut
        memcpy(dst_frame, src_frame, width >> 1);
        src_frame += crop_width >> 2;
        dst_frame += width >> 1;
        src_frame += width >> 1;
        if (pad_width) {
          memset(dst_frame, 127, pad_width >> 2);
          dst_frame +=  pad_width >> 2;
        }
      }
    }
  }
  return 0;
}

} // namespace libyuv