/*

 *  Copyright 2012 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/basic_types.h"

#include "libyuv/compare_row.h"

#ifdef __cplusplus

namespace libyuv {

extern "C" {

#endif

#if ORIGINAL_OPT

uint32_t HammingDistance_C1(const uint8_t* src_a,

                            const uint8_t* src_b,

                            int count) {

  uint32_t diff = 0u;

  int i;

  for (i = 0; i < count; ++i) {

    int x = src_a[i] ^ src_b[i];

    if (x & 1)

      ++diff;

    if (x & 2)

      ++diff;

    if (x & 4)

      ++diff;

    if (x & 8)

      ++diff;

    if (x & 16)

      ++diff;

    if (x & 32)

      ++diff;

    if (x & 64)

      ++diff;

    if (x & 128)

      ++diff;

  }

  return diff;

}

#endif

// Hakmem method for hamming distance.

uint32_t HammingDistance_C(const uint8_t* src_a,

                           const uint8_t* src_b,

                           int count) {

  uint32_t diff = 0u;

  int i;

  for (i = 0; i < count - 3; i += 4) {

    uint32_t x = *((uint32_t*)src_a) ^ *((uint32_t*)src_b);  // NOLINT

    uint32_t u = x - ((x >> 1) & 0x55555555);

    u = ((u >> 2) & 0x33333333) + (u & 0x33333333);

    diff += ((((u + (u >> 4)) & 0x0f0f0f0f) * 0x01010101) >> 24);

    src_a += 4;

    src_b += 4;

  }

  for (; i < count; ++i) {

    uint32_t x = *src_a ^ *src_b;

    uint32_t u = x - ((x >> 1) & 0x55);

    u = ((u >> 2) & 0x33) + (u & 0x33);

    diff += (u + (u >> 4)) & 0x0f;

    src_a += 1;

    src_b += 1;

  }

  return diff;

}

uint32_t SumSquareError_C(const uint8_t* src_a,

                          const uint8_t* src_b,

                          int count) {

  uint32_t sse = 0u;

  int i;

  for (i = 0; i < count; ++i) {

    int diff = src_a[i] - src_b[i];

    sse += (uint32_t)(diff * diff);

  }

  return sse;

}

// hash seed of 5381 recommended.

// Internal C version of HashDjb2 with int sized count for efficiency.

uint32_t HashDjb2_C(const uint8_t* src, int count, uint32_t seed) {

  uint32_t hash = seed;

  int i;

  for (i = 0; i < count; ++i) {

    hash += (hash << 5) + src[i];

  }

  return hash;

}

#ifdef __cplusplus

}  // extern "C"

}  // namespace libyuv

#endif