path: root/gfx/2d/ssse3-scaler.c

/*
 * Copyright © 2013 Soren Sandmann Pedersen
 * Copyright © 2013 Red Hat, Inc.
 * Copyright © 2016 Mozilla Foundation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *
 * Author: Soren Sandmann (soren.sandmann@gmail.com)
 *         Jeff Muizelaar (jmuizelaar@mozilla.com)
 */

/* This has been adapted from the ssse3 code from pixman. It's currently
 * a mess as I want to try it out in practice before finalizing the details.
 */

#include <stdlib.h>
#include <mmintrin.h>
#include <xmmintrin.h>
#include <emmintrin.h>
#include <tmmintrin.h>
#include <stdint.h>
#include <assert.h>
#include "ssse3-scaler.h"

typedef int32_t pixman_fixed_16_16_t;
typedef pixman_fixed_16_16_t pixman_fixed_t;
#define pixman_fixed_1 (pixman_int_to_fixed(1))
#define pixman_fixed_to_int(f) ((int)((f) >> 16))
#define pixman_int_to_fixed(i) ((pixman_fixed_t)((i) << 16))
#define pixman_double_to_fixed(d) ((pixman_fixed_t)((d)*65536.0))
#define PIXMAN_FIXED_INT_MAX 32767
#define PIXMAN_FIXED_INT_MIN -32768
typedef struct pixman_vector pixman_vector_t;

typedef int pixman_bool_t;
typedef int64_t pixman_fixed_32_32_t;
typedef pixman_fixed_32_32_t pixman_fixed_48_16_t;
typedef struct {
  pixman_fixed_48_16_t v[3];
} pixman_vector_48_16_t;

struct pixman_vector {
  pixman_fixed_t vector[3];
};
typedef struct pixman_transform pixman_transform_t;

struct pixman_transform {
  pixman_fixed_t matrix[3][3];
};

#ifdef _MSC_VER
#  define force_inline __forceinline
#else
#  define force_inline __inline__ __attribute__((always_inline))
#endif

#define BILINEAR_INTERPOLATION_BITS 6

static force_inline int pixman_fixed_to_bilinear_weight(pixman_fixed_t x) {
  return (x >> (16 - BILINEAR_INTERPOLATION_BITS)) &
         ((1 << BILINEAR_INTERPOLATION_BITS) - 1);
}

static void pixman_transform_point_31_16_3d(const pixman_transform_t* t,
                                            const pixman_vector_48_16_t* v,
                                            pixman_vector_48_16_t* result) {
  int i;
  int64_t tmp[3][2];

  /* input vector values must have no more than 31 bits (including sign)
   * in the integer part */
  assert(v->v[0] < ((pixman_fixed_48_16_t)1 << (30 + 16)));
  assert(v->v[0] >= -((pixman_fixed_48_16_t)1 << (30 + 16)));
  assert(v->v[1] < ((pixman_fixed_48_16_t)1 << (30 + 16)));
  assert(v->v[1] >= -((pixman_fixed_48_16_t)1 << (30 + 16)));
  assert(v->v[2] < ((pixman_fixed_48_16_t)1 << (30 + 16)));
  assert(v->v[2] >= -((pixman_fixed_48_16_t)1 << (30 + 16)));

  for (i = 0; i < 3; i++) {
    tmp[i][0] = (int64_t)t->matrix[i][0] * (v->v[0] >> 16);
    tmp[i][1] = (int64_t)t->matrix[i][0] * (v->v[0] & 0xFFFF);
    tmp[i][0] += (int64_t)t->matrix[i][1] * (v->v[1] >> 16);
    tmp[i][1] += (int64_t)t->matrix[i][1] * (v->v[1] & 0xFFFF);
    tmp[i][0] += (int64_t)t->matrix[i][2] * (v->v[2] >> 16);
    tmp[i][1] += (int64_t)t->matrix[i][2] * (v->v[2] & 0xFFFF);
  }

  result->v[0] = tmp[0][0] + ((tmp[0][1] + 0x8000) >> 16);
  result->v[1] = tmp[1][0] + ((tmp[1][1] + 0x8000) >> 16);
  result->v[2] = tmp[2][0] + ((tmp[2][1] + 0x8000) >> 16);
}

static pixman_bool_t pixman_transform_point_3d(
    const struct pixman_transform* transform, struct pixman_vector* vector) {
  pixman_vector_48_16_t tmp;
  tmp.v[0] = vector->vector[0];
  tmp.v[1] = vector->vector[1];
  tmp.v[2] = vector->vector[2];

  pixman_transform_point_31_16_3d(transform, &tmp, &tmp);

  vector->vector[0] = tmp.v[0];
  vector->vector[1] = tmp.v[1];
  vector->vector[2] = tmp.v[2];

  return vector->vector[0] == tmp.v[0] && vector->vector[1] == tmp.v[1] &&
         vector->vector[2] == tmp.v[2];
}

struct bits_image_t {
  uint32_t* bits;
  int rowstride;
  pixman_transform_t* transform;
};

typedef struct bits_image_t bits_image_t;
typedef struct {
  int unused;
} pixman_iter_info_t;

typedef struct pixman_iter_t pixman_iter_t;
typedef void (*pixman_iter_fini_t)(pixman_iter_t* iter);

struct pixman_iter_t {
  int x, y;
  pixman_iter_fini_t fini;
  bits_image_t* image;
  uint32_t* buffer;
  int width;
  int height;
  void* data;
};

typedef struct {
  int y;
  uint64_t* buffer;
} line_t;

typedef struct {
  line_t lines[2];
  pixman_fixed_t y;
  pixman_fixed_t x;
  uint64_t data[1];
} bilinear_info_t;

static void ssse3_fetch_horizontal(bits_image_t* image, line_t* line, int y,
                                   pixman_fixed_t x, pixman_fixed_t ux, int n) {
  uint32_t* bits = image->bits + y * image->rowstride;
  __m128i vx = _mm_set_epi16(-(x + 1), x, -(x + 1), x, -(x + ux + 1), x + ux,
                             -(x + ux + 1), x + ux);
  __m128i vux = _mm_set_epi16(-2 * ux, 2 * ux, -2 * ux, 2 * ux, -2 * ux, 2 * ux,
                              -2 * ux, 2 * ux);
  __m128i vaddc = _mm_set_epi16(1, 0, 1, 0, 1, 0, 1, 0);
  __m128i* b = (__m128i*)line->buffer;
  __m128i vrl0, vrl1;

  while ((n -= 2) >= 0) {
    __m128i vw, vr, s;
#ifdef HACKY_PADDING
    if (pixman_fixed_to_int(x + ux) >= image->rowstride) {
      vrl1 = _mm_setzero_si128();
      printf("overread 2loop\n");
    } else {
      if (pixman_fixed_to_int(x + ux) < 0) printf("underflow\n");
      vrl1 = _mm_loadl_epi64(
          (__m128i*)(bits + (pixman_fixed_to_int(x + ux) < 0
                                 ? 0
                                 : pixman_fixed_to_int(x + ux))));
    }
#else
    vrl1 = _mm_loadl_epi64((__m128i*)(bits + pixman_fixed_to_int(x + ux)));
#endif
    /* vrl1: R1, L1 */

  final_pixel:
#ifdef HACKY_PADDING
    vrl0 = _mm_loadl_epi64(
        (__m128i*)(bits +
                   (pixman_fixed_to_int(x) < 0 ? 0 : pixman_fixed_to_int(x))));
#else
    vrl0 = _mm_loadl_epi64((__m128i*)(bits + pixman_fixed_to_int(x)));
#endif
    /* vrl0: R0, L0 */

    /* The weights are based on vx which is a vector of
     *
     *    - (x + 1), x, - (x + 1), x,
     *          - (x + ux + 1), x + ux, - (x + ux + 1), x + ux
     *
     * so the 16 bit weights end up like this:
     *
     *    iw0, w0, iw0, w0, iw1, w1, iw1, w1
     *
     * and after shifting and packing, we get these bytes:
     *
     *    iw0, w0, iw0, w0, iw1, w1, iw1, w1,
     *        iw0, w0, iw0, w0, iw1, w1, iw1, w1,
     *
     * which means the first and the second input pixel
     * have to be interleaved like this:
     *
     *    la0, ra0, lr0, rr0, la1, ra1, lr1, rr1,
     *        lg0, rg0, lb0, rb0, lg1, rg1, lb1, rb1
     *
     * before maddubsw can be used.
     */

    vw = _mm_add_epi16(vaddc,
                       _mm_srli_epi16(vx, 16 - BILINEAR_INTERPOLATION_BITS));
    /* vw: iw0, w0, iw0, w0, iw1, w1, iw1, w1
     */

    vw = _mm_packus_epi16(vw, vw);
    /* vw: iw0, w0, iw0, w0, iw1, w1, iw1, w1,
     *         iw0, w0, iw0, w0, iw1, w1, iw1, w1
     */
    vx = _mm_add_epi16(vx, vux);

    x += 2 * ux;

    vr = _mm_unpacklo_epi16(vrl1, vrl0);
    /* vr: rar0, rar1, rgb0, rgb1, lar0, lar1, lgb0, lgb1 */

    s = _mm_shuffle_epi32(vr, _MM_SHUFFLE(1, 0, 3, 2));
    /* s:  lar0, lar1, lgb0, lgb1, rar0, rar1, rgb0, rgb1 */

    vr = _mm_unpackhi_epi8(vr, s);
    /* vr: la0, ra0, lr0, rr0, la1, ra1, lr1, rr1,
     *         lg0, rg0, lb0, rb0, lg1, rg1, lb1, rb1
     */

    vr = _mm_maddubs_epi16(vr, vw);

    /* When the weight is 0, the inverse weight is
     * 128 which can't be represented in a signed byte.
     * As a result maddubsw computes the following:
     *
     *     r = l * -128 + r * 0
     *
     * rather than the desired
     *
     *     r = l * 128 + r * 0
     *
     * We fix this by taking the absolute value of the
     * result.
     */
    // we can drop this if we use lower precision

    vr = _mm_shuffle_epi32(vr, _MM_SHUFFLE(2, 0, 3, 1));
    /* vr: A0, R0, A1, R1, G0, B0, G1, B1 */
    _mm_store_si128(b++, vr);
  }

  if (n == -1) {
    vrl1 = _mm_setzero_si128();
    goto final_pixel;
  }

  line->y = y;
}

// scale a line of destination pixels
static uint32_t* ssse3_fetch_bilinear_cover(pixman_iter_t* iter,
                                            const uint32_t* mask) {
  pixman_fixed_t fx, ux;
  bilinear_info_t* info = iter->data;
  line_t *line0, *line1;
  int y0, y1;
  int32_t dist_y;
  __m128i vw, uvw;
  int i;

  fx = info->x;
  ux = iter->image->transform->matrix[0][0];

  y0 = pixman_fixed_to_int(info->y);
  if (y0 < 0) *(volatile char*)0 = 9;
  y1 = y0 + 1;

  // clamping in y direction
  if (y1 >= iter->height) {
    y1 = iter->height - 1;
  }

  line0 = &info->lines[y0 & 0x01];
  line1 = &info->lines[y1 & 0x01];

  if (line0->y != y0) {
    ssse3_fetch_horizontal(iter->image, line0, y0, fx, ux, iter->width);
  }

  if (line1->y != y1) {
    ssse3_fetch_horizontal(iter->image, line1, y1, fx, ux, iter->width);
  }

#ifdef PIXMAN_STYLE_INTERPOLATION
  dist_y = pixman_fixed_to_bilinear_weight(info->y);
  dist_y <<= (16 - BILINEAR_INTERPOLATION_BITS);

  vw = _mm_set_epi16(dist_y, dist_y, dist_y, dist_y, dist_y, dist_y, dist_y,
                     dist_y);

#else
  // setup the weights for the top (vw) and bottom (uvw) lines
  dist_y = pixman_fixed_to_bilinear_weight(info->y);
  // we use 15 instead of 16 because we need an extra bit to handle when the
  // weights are 0 and 1
  dist_y <<= (15 - BILINEAR_INTERPOLATION_BITS);

  vw = _mm_set_epi16(dist_y, dist_y, dist_y, dist_y, dist_y, dist_y, dist_y,
                     dist_y);

  dist_y = (1 << BILINEAR_INTERPOLATION_BITS) -
           pixman_fixed_to_bilinear_weight(info->y);
  dist_y <<= (15 - BILINEAR_INTERPOLATION_BITS);
  uvw = _mm_set_epi16(dist_y, dist_y, dist_y, dist_y, dist_y, dist_y, dist_y,
                      dist_y);
#endif

  for (i = 0; i + 3 < iter->width; i += 4) {
    __m128i top0 = _mm_load_si128((__m128i*)(line0->buffer + i));
    __m128i bot0 = _mm_load_si128((__m128i*)(line1->buffer + i));
    __m128i top1 = _mm_load_si128((__m128i*)(line0->buffer + i + 2));
    __m128i bot1 = _mm_load_si128((__m128i*)(line1->buffer + i + 2));
#ifdef PIXMAN_STYLE_INTERPOLATION
    __m128i r0, r1, tmp, p;

    r0 = _mm_mulhi_epu16(_mm_sub_epi16(bot0, top0), vw);
    tmp = _mm_cmplt_epi16(bot0, top0);
    tmp = _mm_and_si128(tmp, vw);
    r0 = _mm_sub_epi16(r0, tmp);
    r0 = _mm_add_epi16(r0, top0);
    r0 = _mm_srli_epi16(r0, BILINEAR_INTERPOLATION_BITS);
    /* r0:  A0 R0 A1 R1 G0 B0 G1 B1 */
    // r0 = _mm_shuffle_epi32 (r0, _MM_SHUFFLE (2, 0, 3, 1));
    /* r0:  A1 R1 G1 B1 A0 R0 G0 B0 */

    // tmp = bot1 < top1 ? vw : 0;
    // r1 = (bot1 - top1)*vw + top1 - tmp
    // r1 = bot1*vw - vw*top1 + top1 - tmp
    // r1 = bot1*vw + top1 - vw*top1 - tmp
    // r1 = bot1*vw + top1*(1 - vw) - tmp
    r1 = _mm_mulhi_epu16(_mm_sub_epi16(bot1, top1), vw);
    tmp = _mm_cmplt_epi16(bot1, top1);
    tmp = _mm_and_si128(tmp, vw);
    r1 = _mm_sub_epi16(r1, tmp);
    r1 = _mm_add_epi16(r1, top1);
    r1 = _mm_srli_epi16(r1, BILINEAR_INTERPOLATION_BITS);
    // r1 = _mm_shuffle_epi32 (r1, _MM_SHUFFLE (2, 0, 3, 1));
    /* r1: A3 R3 G3 B3 A2 R2 G2 B2 */
#else
    __m128i r0, r1, p;
    top0 = _mm_mulhi_epu16(top0, uvw);
    bot0 = _mm_mulhi_epu16(bot0, vw);
    r0 = _mm_add_epi16(top0, bot0);
    r0 = _mm_srli_epi16(r0, BILINEAR_INTERPOLATION_BITS - 1);

    top1 = _mm_mulhi_epu16(top1, uvw);
    bot1 = _mm_mulhi_epu16(bot1, vw);
    r1 = _mm_add_epi16(top1, bot1);
    r1 = _mm_srli_epi16(r1, BILINEAR_INTERPOLATION_BITS - 1);
#endif

    p = _mm_packus_epi16(r0, r1);
    _mm_storeu_si128((__m128i*)(iter->buffer + i), p);
  }

  while (i < iter->width) {
    __m128i top0 = _mm_load_si128((__m128i*)(line0->buffer + i));
    __m128i bot0 = _mm_load_si128((__m128i*)(line1->buffer + i));

#ifdef PIXMAN_STYLE_INTERPOLATION
    __m128i r0, tmp, p;
    r0 = _mm_mulhi_epu16(_mm_sub_epi16(bot0, top0), vw);
    tmp = _mm_cmplt_epi16(bot0, top0);
    tmp = _mm_and_si128(tmp, vw);
    r0 = _mm_sub_epi16(r0, tmp);
    r0 = _mm_add_epi16(r0, top0);
    r0 = _mm_srli_epi16(r0, BILINEAR_INTERPOLATION_BITS);
    /* r0:  A0 R0 A1 R1 G0 B0 G1 B1 */
    r0 = _mm_shuffle_epi32(r0, _MM_SHUFFLE(2, 0, 3, 1));
    /* r0:  A1 R1 G1 B1 A0 R0 G0 B0 */
#else
    __m128i r0, p;
    top0 = _mm_mulhi_epu16(top0, uvw);
    bot0 = _mm_mulhi_epu16(bot0, vw);
    r0 = _mm_add_epi16(top0, bot0);
    r0 = _mm_srli_epi16(r0, BILINEAR_INTERPOLATION_BITS - 1);
#endif

    p = _mm_packus_epi16(r0, r0);

    if (iter->width - i == 1) {
      *(uint32_t*)(iter->buffer + i) = _mm_cvtsi128_si32(p);
      i++;
    } else {
      _mm_storel_epi64((__m128i*)(iter->buffer + i), p);
      i += 2;
    }
  }

  info->y += iter->image->transform->matrix[1][1];

  return iter->buffer;
}

static void ssse3_bilinear_cover_iter_fini(pixman_iter_t* iter) {
  free(iter->data);
}

static void ssse3_bilinear_cover_iter_init(pixman_iter_t* iter) {
  int width = iter->width;
  bilinear_info_t* info;
  pixman_vector_t v;

  if (iter->x > PIXMAN_FIXED_INT_MAX || iter->x < PIXMAN_FIXED_INT_MIN ||
      iter->y > PIXMAN_FIXED_INT_MAX || iter->y < PIXMAN_FIXED_INT_MIN)
    goto fail;

  /* Reference point is the center of the pixel */
  v.vector[0] = pixman_int_to_fixed(iter->x) + pixman_fixed_1 / 2;
  v.vector[1] = pixman_int_to_fixed(iter->y) + pixman_fixed_1 / 2;
  v.vector[2] = pixman_fixed_1;

  if (!pixman_transform_point_3d(iter->image->transform, &v)) goto fail;

  info = malloc(sizeof(*info) + (2 * width - 1) * sizeof(uint64_t) + 64);
  if (!info) goto fail;

  info->x = v.vector[0] - pixman_fixed_1 / 2;
  info->y = v.vector[1] - pixman_fixed_1 / 2;

#define ALIGN(addr) ((void*)((((uintptr_t)(addr)) + 15) & (~15)))

  /* It is safe to set the y coordinates to -1 initially
   * because COVER_CLIP_BILINEAR ensures that we will only
   * be asked to fetch lines in the [0, height) interval
   */
  info->lines[0].y = -1;
  info->lines[0].buffer = ALIGN(&(info->data[0]));
  info->lines[1].y = -1;
  info->lines[1].buffer = ALIGN(info->lines[0].buffer + width);

  iter->fini = ssse3_bilinear_cover_iter_fini;

  iter->data = info;
  return;

fail:
  /* Something went wrong, either a bad matrix or OOM; in such cases,
   * we don't guarantee any particular rendering.
   */
  iter->fini = NULL;
}

/* scale the src from src_width/height to dest_width/height drawn
 * into the rectangle x,y width,height
 * src_stride and dst_stride are 4 byte units */
bool ssse3_scale_data(uint32_t* src, int src_width, int src_height,
                      int src_stride, uint32_t* dest, int dest_width,
                      int dest_height, int dest_stride, int x, int y, int width,
                      int height) {
  // XXX: assert(src_width > 1)
  pixman_transform_t transform = {
      {{pixman_fixed_1, 0, 0}, {0, pixman_fixed_1, 0}, {0, 0, pixman_fixed_1}}};
  double width_scale = ((double)src_width) / dest_width;
  double height_scale = ((double)src_height) / dest_height;
#define AVOID_PADDING
#ifdef AVOID_PADDING
  // scale up by enough that we don't read outside of the bounds of the source
  // surface currently this is required to avoid reading out of bounds.
  if (width_scale < 1) {
    width_scale = (double)(src_width - 1) / dest_width;
    transform.matrix[0][2] = pixman_fixed_1 / 2;
  }
  if (height_scale < 1) {
    height_scale = (double)(src_height - 1) / dest_height;
    transform.matrix[1][2] = pixman_fixed_1 / 2;
  }
#endif
  transform.matrix[0][0] = pixman_double_to_fixed(width_scale);
  transform.matrix[1][1] = pixman_double_to_fixed(height_scale);
  transform.matrix[2][2] = pixman_fixed_1;

  bits_image_t image;
  image.bits = src;
  image.transform = &transform;
  image.rowstride = src_stride;

  pixman_iter_t iter;
  iter.image = &image;
  iter.x = x;
  iter.y = y;
  iter.width = width;
  iter.height = src_height;
  iter.buffer = dest;
  iter.data = NULL;

  ssse3_bilinear_cover_iter_init(&iter);

  if (!iter.fini) return false;

  if (iter.data) {
    for (int iy = 0; iy < height; iy++) {
      ssse3_fetch_bilinear_cover(&iter, NULL);
      iter.buffer += dest_stride;
    }
    ssse3_bilinear_cover_iter_fini(&iter);
  }
  return true;
}