/*

 * Copyright © 2014 RISC OS Open Ltd

 *

 * Permission to use, copy, modify, distribute, and sell this software and its

 * documentation for any purpose is hereby granted without fee, provided that

 * the above copyright notice appear in all copies and that both that

 * copyright notice and this permission notice appear in supporting

 * documentation, and that the name of the copyright holders not be used in

 * advertising or publicity pertaining to distribution of the software without

 * specific, written prior permission.  The copyright holders make no

 * representations about the suitability of this software for any purpose.  It

 * is provided "as is" without express or implied warranty.

 *

 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS

 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND

 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY

 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN

 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING

 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

 * SOFTWARE.

 *

 * Author:  Ben Avison (bavison@riscosopen.org)

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <stdint.h>

#include "utils.h"

#ifdef HAVE_GETTIMEOFDAY

#include <sys/time.h>

#else

#include <time.h>

#endif

#define WIDTH  1920

#define HEIGHT 1080

/* How much data to read to flush all cached data to RAM */

#define MAX_L2CACHE_SIZE (8 * 1024 * 1024)

#define PAGE_SIZE (4 * 1024)

struct bench_info

{

    pixman_op_t           op;

    pixman_transform_t    transform;

    pixman_image_t       *src_image;

    pixman_image_t       *mask_image;

    pixman_image_t       *dest_image;

    int32_t               src_x;

    int32_t               src_y;

};

typedef struct bench_info bench_info_t;

struct box_48_16

{

    pixman_fixed_48_16_t        x1;

    pixman_fixed_48_16_t        y1;

    pixman_fixed_48_16_t        x2;

    pixman_fixed_48_16_t        y2;

};

typedef struct box_48_16 box_48_16_t;

/* This function is copied verbatim from pixman.c. */

static pixman_bool_t

compute_transformed_extents (pixman_transform_t   *transform,

			     const pixman_box32_t *extents,

			     box_48_16_t          *transformed)

{

    pixman_fixed_48_16_t tx1, ty1, tx2, ty2;

    pixman_fixed_t x1, y1, x2, y2;

    int i;

    x1 = pixman_int_to_fixed (extents->x1) + pixman_fixed_1 / 2;

    y1 = pixman_int_to_fixed (extents->y1) + pixman_fixed_1 / 2;

    x2 = pixman_int_to_fixed (extents->x2) - pixman_fixed_1 / 2;

    y2 = pixman_int_to_fixed (extents->y2) - pixman_fixed_1 / 2;

    if (!transform)

    {

	transformed->x1 = x1;

	transformed->y1 = y1;

	transformed->x2 = x2;

	transformed->y2 = y2;

	return TRUE;

    }

    tx1 = ty1 = INT64_MAX;

    tx2 = ty2 = INT64_MIN;

    for (i = 0; i < 4; ++i)

    {

	pixman_fixed_48_16_t tx, ty;

	pixman_vector_t v;

	v.vector[0] = (i & 0x01)? x1 : x2;

	v.vector[1] = (i & 0x02)? y1 : y2;

	v.vector[2] = pixman_fixed_1;

	if (!pixman_transform_point (transform, &v))

	    return FALSE;

	tx = (pixman_fixed_48_16_t)v.vector[0];

	ty = (pixman_fixed_48_16_t)v.vector[1];

	if (tx < tx1)

	    tx1 = tx;

	if (ty < ty1)

	    ty1 = ty;

	if (tx > tx2)

	    tx2 = tx;

	if (ty > ty2)

	    ty2 = ty;

    }

    transformed->x1 = tx1;

    transformed->y1 = ty1;

    transformed->x2 = tx2;

    transformed->y2 = ty2;

    return TRUE;

}

static void

create_image (uint32_t                   width,

              uint32_t                   height,

              pixman_format_code_t       format,

              pixman_filter_t            filter,

              uint32_t                 **bits,

              pixman_image_t           **image)

{

    uint32_t stride = (width * PIXMAN_FORMAT_BPP (format) + 31) / 32 * 4;

    *bits = aligned_malloc (PAGE_SIZE, stride * height);

    memset (*bits, 0xCC, stride * height);

    *image = pixman_image_create_bits (format, width, height, *bits, stride);

    pixman_image_set_repeat (*image, PIXMAN_REPEAT_NORMAL);

    pixman_image_set_filter (*image, filter, NULL, 0);

}

/* This needs to match the shortest cacheline length we expect to encounter */

#define CACHE_CLEAN_INCREMENT 32

static void

flush_cache (void)

{

    static const char clean_space[MAX_L2CACHE_SIZE];

    volatile const char *x = clean_space;

    const char *clean_end = clean_space + sizeof clean_space;

    while (x < clean_end)

    {

        (void) *x;

        x += CACHE_CLEAN_INCREMENT;

    }

}

/* Obtain current time in microseconds modulo 2^32 */

uint32_t

gettimei (void)

{

#ifdef HAVE_GETTIMEOFDAY

    struct timeval tv;

    gettimeofday (&tv, NULL);

    return tv.tv_sec * 1000000 + tv.tv_usec;

#else

    return (uint64_t) clock () * 1000000 / CLOCKS_PER_SEC;

#endif

}

static void

pixman_image_composite_wrapper (const pixman_composite_info_t *info)

{

    pixman_image_composite (info->op,

                            info->src_image, info->mask_image, info->dest_image,

                            info->src_x, info->src_y,

                            info->mask_x, info->mask_y,

                            info->dest_x, info->dest_y,

                            info->width, info->height);

}

static void

pixman_image_composite_empty (const pixman_composite_info_t *info)

{

    pixman_image_composite (info->op,

                            info->src_image, info->mask_image, info->dest_image,

                            info->src_x, info->src_y,

                            info->mask_x, info->mask_y,

                            info->dest_x, info->dest_y,

                            1, 1);

}

static void

bench (const bench_info_t *bi,

       uint32_t            max_n,

       uint32_t            max_time,

       uint32_t           *ret_n,

       uint32_t           *ret_time,

       void              (*func) (const pixman_composite_info_t *info))

{

    uint32_t n = 0;

    uint32_t t0;

    uint32_t t1;

    uint32_t x = 0;

    pixman_transform_t t;

    pixman_composite_info_t info;

    t = bi->transform;

    info.op = bi->op;

    info.src_image = bi->src_image;

    info.mask_image = bi->mask_image;

    info.dest_image = bi->dest_image;

    info.src_x = 0;

    info.src_y = 0;

    info.mask_x = 0;

    info.mask_y = 0;

    /* info.dest_x set below */

    info.dest_y = 0;

    info.width = WIDTH;

    info.height = HEIGHT;

    t0 = gettimei ();

    do

    {

        if (++x >= 64)

            x = 0;

        info.dest_x = 63 - x;

        t.matrix[0][2] = pixman_int_to_fixed (bi->src_x + x);

        t.matrix[1][2] = pixman_int_to_fixed (bi->src_y);

        pixman_image_set_transform (bi->src_image, &t);

        if (bi->mask_image)

            pixman_image_set_transform (bi->mask_image, &t);

        func (&info;;

        t1 = gettimei ();

    }

    while (++n < max_n && (t1 - t0) < max_time);

    if (ret_n)

        *ret_n = n;

    *ret_time = t1 - t0;

}

int

parse_fixed_argument (char *arg, pixman_fixed_t *value)

{

    char *tailptr;

    *value = pixman_double_to_fixed (strtod (arg, &tailptr));

    return *tailptr == '\0';

}

int

parse_arguments (int                   argc,

                 char                 *argv[],

                 pixman_transform_t   *t,

                 pixman_op_t          *op,

                 pixman_format_code_t *src_format,

                 pixman_format_code_t *mask_format,

                 pixman_format_code_t *dest_format)

{

    if (!parse_fixed_argument (*argv, &t->matrix[0][0]))

        return 0;

    if (*++argv == NULL)

        return 1;

    if (!parse_fixed_argument (*argv, &t->matrix[0][1]))

        return 0;

    if (*++argv == NULL)

        return 1;

    if (!parse_fixed_argument (*argv, &t->matrix[1][0]))

        return 0;

    if (*++argv == NULL)

        return 1;

    if (!parse_fixed_argument (*argv, &t->matrix[1][1]))

        return 0;

    if (*++argv == NULL)

        return 1;

    *op = operator_from_string (*argv);

    if (*op == PIXMAN_OP_NONE)

        return 0;

    if (*++argv == NULL)

        return 1;

    *src_format = format_from_string (*argv);

    if (*src_format == PIXMAN_null)

        return 0;

    ++argv;

    if (argv[0] && argv[1])

    {

        *mask_format = format_from_string (*argv);

        if (*mask_format == PIXMAN_null)

            return 0;

        ++argv;

    }

    if (*argv)

    {

        *dest_format = format_from_string (*argv);

        if (*dest_format == PIXMAN_null)

            return 0;

    }

    return 1;

}

static void

run_benchmark (const bench_info_t *bi)

{

    uint32_t n;  /* number of iterations in at least 5 seconds */

    uint32_t t1; /* time taken to do n iterations, microseconds */

    uint32_t t2; /* calling overhead for n iterations, microseconds */

    flush_cache ();

    bench (bi, UINT32_MAX, 5000000, &n, &t1, pixman_image_composite_wrapper);

    bench (bi, n, UINT32_MAX, NULL, &t2, pixman_image_composite_empty);

    /* The result indicates the output rate in megapixels/second */

    printf ("%6.2f\n", (double) n * WIDTH * HEIGHT / (t1 - t2));

}

int

main (int argc, char *argv[])

{

    bench_info_t         binfo;

    pixman_filter_t      filter      = PIXMAN_FILTER_NEAREST;

    pixman_format_code_t src_format  = PIXMAN_a8r8g8b8;

    pixman_format_code_t mask_format = 0;

    pixman_format_code_t dest_format = PIXMAN_a8r8g8b8;

    pixman_box32_t       dest_box    = { 0, 0, WIDTH, HEIGHT };

    box_48_16_t          transformed = { 0 };

    int32_t xmin, ymin, xmax, ymax;

    uint32_t *src, *mask, *dest;

    binfo.op         = PIXMAN_OP_SRC;

    binfo.mask_image = NULL;

    pixman_transform_init_identity (&binfo.transform);

    ++argv;

    if (*argv && (*argv)[0] == '-' && (*argv)[1] == 'n')

    {

        filter = PIXMAN_FILTER_NEAREST;

        ++argv;

        --argc;

    }

    if (*argv && (*argv)[0] == '-' && (*argv)[1] == 'b')

    {

        filter = PIXMAN_FILTER_BILINEAR;

        ++argv;

        --argc;

    }

    if (argc == 1 ||

        !parse_arguments (argc, argv, &binfo.transform, &binfo.op,

                          &src_format, &mask_format, &dest_format))

    {

        printf ("Usage: affine-bench [-n] [-b] axx [axy] [ayx] [ayy] [combine type]\n");

        printf ("                    [src format] [mask format] [dest format]\n");

        printf ("  -n : nearest scaling (default)\n");

        printf ("  -b : bilinear scaling\n");

        printf ("  axx : x_out:x_in factor\n");

        printf ("  axy : x_out:y_in factor (default 0)\n");

        printf ("  ayx : y_out:x_in factor (default 0)\n");

        printf ("  ayy : y_out:y_in factor (default 1)\n");

        printf ("  combine type : src, over, in etc (default src)\n");

        printf ("  src format : a8r8g8b8, r5g6b5 etc (default a8r8g8b8)\n");

        printf ("  mask format : as for src format, but no mask used if omitted\n");

        printf ("  dest format : as for src format (default a8r8g8b8)\n");

        printf ("The output is a single number in megapixels/second.\n");

        return EXIT_FAILURE;

    }

    /* Compute required extents for source and mask image so they qualify

     * for COVER fast paths and get the flags in pixman.c:analyze_extent().

     * These computations are for FAST_PATH_SAMPLES_COVER_CLIP_BILINEAR,

     * but at the same time they also allow COVER_CLIP_NEAREST.

     */

    compute_transformed_extents (&binfo.transform, &dest_box, &transformed);

    xmin = pixman_fixed_to_int (transformed.x1 - pixman_fixed_1 / 2);

    ymin = pixman_fixed_to_int (transformed.y1 - pixman_fixed_1 / 2);

    xmax = pixman_fixed_to_int (transformed.x2 + pixman_fixed_1 / 2);

    ymax = pixman_fixed_to_int (transformed.y2 + pixman_fixed_1 / 2);

    /* Note:

     * The upper limits can be reduced to the following when fetchers

     * are guaranteed to not access pixels with zero weight. This concerns

     * particularly all bilinear samplers.

     *

     * xmax = pixman_fixed_to_int (transformed.x2 + pixman_fixed_1 / 2 - pixman_fixed_e);

     * ymax = pixman_fixed_to_int (transformed.y2 + pixman_fixed_1 / 2 - pixman_fixed_e);

     * This is equivalent to subtracting 0.5 and rounding up, rather than

     * subtracting 0.5, rounding down and adding 1.

     */

    binfo.src_x = -xmin;

    binfo.src_y = -ymin;

    /* Always over-allocate width by 64 pixels for all src, mask and dst,

     * so that we can iterate over an x-offset 0..63 in bench ().

     * This is similar to lowlevel-blt-bench, which uses the same method

     * to hit different cacheline misalignments.

     */

    create_image (xmax - xmin + 64, ymax - ymin + 1, src_format, filter,

                  &src, &binfo.src_image);

    if (mask_format)

    {

        create_image (xmax - xmin + 64, ymax - ymin + 1, mask_format, filter,

                      &mask, &binfo.mask_image);

        if ((PIXMAN_FORMAT_R(mask_format) ||

             PIXMAN_FORMAT_G(mask_format) ||

             PIXMAN_FORMAT_B(mask_format)))

        {

            pixman_image_set_component_alpha (binfo.mask_image, 1);

        }

    }

    create_image (WIDTH + 64, HEIGHT, dest_format, filter,

                  &dest, &binfo.dest_image);

    run_benchmark (&binfo);

    return EXIT_SUCCESS;

}