/*
 *  Copyright (c) 2023 The WebM 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 <assert.h>
#include <immintrin.h>

#include "./vpx_dsp_rtcd.h"

void vpx_comp_avg_pred_avx2(uint8_t *comp_pred, const uint8_t *pred, int width,
                            int height, const uint8_t *ref, int ref_stride) {
  int row = 0;
  // comp_pred and pred must be 32 byte aligned.
  assert(((intptr_t)comp_pred % 32) == 0);
  assert(((intptr_t)pred % 32) == 0);

  if (width == 8) {
    assert(height % 4 == 0);
    do {
      const __m256i p = _mm256_load_si256((const __m256i *)pred);
      const __m128i r_0 = _mm_loadl_epi64((const __m128i *)ref);
      const __m128i r_1 =
          _mm_loadl_epi64((const __m128i *)(ref + 2 * ref_stride));

      const __m128i r1 = _mm_castps_si128(_mm_loadh_pi(
          _mm_castsi128_ps(r_0), (const __m64 *)(ref + ref_stride)));
      const __m128i r2 = _mm_castps_si128(_mm_loadh_pi(
          _mm_castsi128_ps(r_1), (const __m64 *)(ref + 3 * ref_stride)));

      const __m256i ref_0123 =
          _mm256_inserti128_si256(_mm256_castsi128_si256(r1), r2, 1);
      const __m256i avg = _mm256_avg_epu8(p, ref_0123);

      _mm256_store_si256((__m256i *)comp_pred, avg);

      row += 4;
      pred += 32;
      comp_pred += 32;
      ref += 4 * ref_stride;
    } while (row < height);
  } else if (width == 16) {
    assert(height % 4 == 0);
    do {
      const __m256i pred_0 = _mm256_load_si256((const __m256i *)pred);
      const __m256i pred_1 = _mm256_load_si256((const __m256i *)(pred + 32));
      const __m256i tmp0 =
          _mm256_castsi128_si256(_mm_loadu_si128((const __m128i *)ref));
      const __m256i ref_0 = _mm256_inserti128_si256(
          tmp0, _mm_loadu_si128((const __m128i *)(ref + ref_stride)), 1);
      const __m256i tmp1 = _mm256_castsi128_si256(
          _mm_loadu_si128((const __m128i *)(ref + 2 * ref_stride)));
      const __m256i ref_1 = _mm256_inserti128_si256(
          tmp1, _mm_loadu_si128((const __m128i *)(ref + 3 * ref_stride)), 1);
      const __m256i average_0 = _mm256_avg_epu8(pred_0, ref_0);
      const __m256i average_1 = _mm256_avg_epu8(pred_1, ref_1);
      _mm256_store_si256((__m256i *)comp_pred, average_0);
      _mm256_store_si256((__m256i *)(comp_pred + 32), average_1);

      row += 4;
      pred += 64;
      comp_pred += 64;
      ref += 4 * ref_stride;
    } while (row < height);
  } else if (width == 32) {
    assert(height % 2 == 0);
    do {
      const __m256i pred_0 = _mm256_load_si256((const __m256i *)pred);
      const __m256i pred_1 = _mm256_load_si256((const __m256i *)(pred + 32));
      const __m256i ref_0 = _mm256_loadu_si256((const __m256i *)ref);
      const __m256i ref_1 =
          _mm256_loadu_si256((const __m256i *)(ref + ref_stride));
      const __m256i average_0 = _mm256_avg_epu8(pred_0, ref_0);
      const __m256i average_1 = _mm256_avg_epu8(pred_1, ref_1);
      _mm256_store_si256((__m256i *)comp_pred, average_0);
      _mm256_store_si256((__m256i *)(comp_pred + 32), average_1);

      row += 2;
      pred += 64;
      comp_pred += 64;
      ref += 2 * ref_stride;
    } while (row < height);
  } else if (width % 64 == 0) {
    do {
      int x;
      for (x = 0; x < width; x += 64) {
        const __m256i pred_0 = _mm256_load_si256((const __m256i *)(pred + x));
        const __m256i pred_1 =
            _mm256_load_si256((const __m256i *)(pred + x + 32));
        const __m256i ref_0 = _mm256_loadu_si256((const __m256i *)(ref + x));
        const __m256i ref_1 =
            _mm256_loadu_si256((const __m256i *)(ref + x + 32));
        const __m256i average_0 = _mm256_avg_epu8(pred_0, ref_0);
        const __m256i average_1 = _mm256_avg_epu8(pred_1, ref_1);
        _mm256_store_si256((__m256i *)(comp_pred + x), average_0);
        _mm256_store_si256((__m256i *)(comp_pred + x + 32), average_1);
      }
      row++;
      pred += width;
      comp_pred += width;
      ref += ref_stride;
    } while (row < height);
  } else {
    vpx_comp_avg_pred_sse2(comp_pred, pred, width, height, ref, ref_stride);
  }
}