/*
 * Copyright 2006-2009, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Axel Dörfler, axeld@pinc-software.de
 *
 * The phase coefficient computation was taken from the X driver written by
 * Alan Hourihane and David Dawes.
 */


#include "accelerant.h"
#include "accelerant_protos.h"
#include "commands.h"

#include <Debug.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>

#include <AGP.h>


#undef TRACE
//#define TRACE_OVERLAY
#ifdef TRACE_OVERLAY
#       define TRACE(x...) _sPrintf("intel_extreme: " x)
#else
#       define TRACE(x...)
#endif

#define ERROR(x...) _sPrintf("intel_extreme: " x)
#define CALLED(x...) TRACE("CALLED %s\n", __PRETTY_FUNCTION__)


#define NUM_HORIZONTAL_TAPS             5
#define NUM_VERTICAL_TAPS               3
#define NUM_HORIZONTAL_UV_TAPS  3
#define NUM_VERTICAL_UV_TAPS    3
#define NUM_PHASES                              17
#define MAX_TAPS                                5

struct phase_coefficient {
        uint8   sign;
        uint8   exponent;
        uint16  mantissa;
};


/*!     Splits the coefficient floating point value into the 3 components
        sign, mantissa, and exponent.
*/
static bool
split_coefficient(double &coefficient, int32 mantissaSize,
        phase_coefficient &splitCoefficient)
{
        double absCoefficient = fabs(coefficient);

        int sign;
        if (coefficient < 0.0)
                sign = 1;
        else
                sign = 0;

        int32 intCoefficient, res;
        int32 maxValue = 1 << mantissaSize;
        res = 12 - mantissaSize;

        if ((intCoefficient = (int)(absCoefficient * 4 * maxValue + 0.5))
                        < maxValue) {
                splitCoefficient.exponent = 3;
                splitCoefficient.mantissa = intCoefficient << res;
                coefficient = (double)intCoefficient / (double)(4 * maxValue);
        } else if ((intCoefficient = (int)(absCoefficient * 2 * maxValue + 0.5))
                        < maxValue) {
                splitCoefficient.exponent = 2;
                splitCoefficient.mantissa = intCoefficient << res;
                coefficient = (double)intCoefficient / (double)(2 * maxValue);
        } else if ((intCoefficient = (int)(absCoefficient * maxValue + 0.5))
                        < maxValue) {
                splitCoefficient.exponent = 1;
                splitCoefficient.mantissa = intCoefficient << res;
                coefficient = (double)intCoefficient / (double)maxValue;
        } else if ((intCoefficient = (int)(absCoefficient * maxValue * 0.5 + 0.5))
                        < maxValue) {
                splitCoefficient.exponent = 0;
                splitCoefficient.mantissa = intCoefficient << res;
                coefficient = (double)intCoefficient / (double)(maxValue / 2);
        } else {
                // coefficient out of range
                return false;
        }

        splitCoefficient.sign = sign;
        if (sign)
                coefficient = -coefficient;

        return true;
}


static void
update_coefficients(int32 taps, double filterCutOff, bool horizontal, bool isY,
        phase_coefficient* splitCoefficients)
{
        if (filterCutOff < 1)
                filterCutOff = 1;
        if (filterCutOff > 3)
                filterCutOff = 3;

        bool isVerticalUV = !horizontal && !isY;
        int32 mantissaSize = horizontal ? 7 : 6;

        double rawCoefficients[MAX_TAPS * 32], coefficients[NUM_PHASES][MAX_TAPS];

        int32 num = taps * 16;
        for (int32 i = 0; i < num * 2; i++) {
                double sinc;
                double value = (1.0 / filterCutOff) * taps * M_PI * (i - num)
                        / (2 * num);
                if (value == 0.0)
                        sinc = 1.0;
                else
                        sinc = sin(value) / value;

                // Hamming window
                double window = (0.5 - 0.5 * cos(i * M_PI / num));
                rawCoefficients[i] = sinc * window;
        }

        for (int32 i = 0; i < NUM_PHASES; i++) {
                // Normalise the coefficients
                double sum = 0.0;
                int32 pos;
                for (int32 j = 0; j < taps; j++) {
                        pos = i + j * 32;
                        sum += rawCoefficients[pos];
                }
                for (int32 j = 0; j < taps; j++) {
                        pos = i + j * 32;
                        coefficients[i][j] = rawCoefficients[pos] / sum;
                }

                // split them into sign/mantissa/exponent
                for (int32 j = 0; j < taps; j++) {
                        pos = j + i * taps;

                        split_coefficient(coefficients[i][j], mantissaSize
                                + (((j == (taps - 1) / 2) && !isVerticalUV) ? 2 : 0),
                                splitCoefficients[pos]);
                }

                int32 tapAdjust[MAX_TAPS];
                tapAdjust[0] = (taps - 1) / 2;
                for (int32 j = 1, k = 1; j <= tapAdjust[0]; j++, k++) {
                        tapAdjust[k] = tapAdjust[0] - j;
                        tapAdjust[++k] = tapAdjust[0] + j;
                }

                // Adjust the coefficients
                sum = 0.0;
                for (int32 j = 0; j < taps; j++) {
                        sum += coefficients[i][j];
                }

                if (sum != 1.0) {
                        for (int32 k = 0; k < taps; k++) {
                                int32 tap2Fix = tapAdjust[k];
                                double diff = 1.0 - sum;

                                coefficients[i][tap2Fix] += diff;
                                pos = tap2Fix + i * taps;

                                split_coefficient(coefficients[i][tap2Fix], mantissaSize
                                        + (((tap2Fix == (taps - 1) / 2) && !isVerticalUV) ? 2 : 0),
                                        splitCoefficients[pos]);

                                sum = 0.0;
                                for (int32 j = 0; j < taps; j++) {
                                        sum += coefficients[i][j];
                                }
                                if (sum == 1.0)
                                        break;
                        }
                }
        }
}


static void
set_color_key(uint8 red, uint8 green, uint8 blue, uint8 redMask,
        uint8 greenMask, uint8 blueMask)
{
        overlay_registers* registers = gInfo->overlay_registers;

        registers->color_key_red = red;
        registers->color_key_green = green;
        registers->color_key_blue = blue;
        registers->color_key_mask_red = ~redMask;
        registers->color_key_mask_green = ~greenMask;
        registers->color_key_mask_blue = ~blueMask;
        registers->color_key_enabled = true;
}


static void
set_color_key(const overlay_window* window)
{
        switch (gInfo->shared_info->current_mode.space) {
                case B_CMAP8:
                        set_color_key(0, 0, window->blue.value, 0x0, 0x0, 0xff);
                        break;
                case B_RGB15:
                        set_color_key(window->red.value << 3, window->green.value << 3,
                                window->blue.value << 3, window->red.mask << 3,
                                window->green.mask << 3, window->blue.mask << 3);
                        break;
                case B_RGB16:
                        set_color_key(window->red.value << 3, window->green.value << 2,
                                window->blue.value << 3, window->red.mask << 3,
                                window->green.mask << 2, window->blue.mask << 3);
                        break;

                default:
                        set_color_key(window->red.value, window->green.value,
                                window->blue.value, window->red.mask, window->green.mask,
                                window->blue.mask);
                        break;
        }
}


static void
update_overlay(bool updateCoefficients)
{
        if (!gInfo->shared_info->overlay_active
                || gInfo->shared_info->device_type.IsModel(INTEL_MODEL_965))
                return;

        QueueCommands queue(gInfo->shared_info->primary_ring_buffer);
        queue.PutFlush();
        queue.PutWaitFor(COMMAND_WAIT_FOR_OVERLAY_FLIP);
        queue.PutOverlayFlip(COMMAND_OVERLAY_CONTINUE, updateCoefficients);

        // make sure the flip is done now
        queue.PutWaitFor(COMMAND_WAIT_FOR_OVERLAY_FLIP);
        queue.PutFlush();

        TRACE("%s: UP: %lx, TST: %lx, ST: %lx, CMD: %lx (%lx), ERR: %lx\n",
                __func__, read32(INTEL_OVERLAY_UPDATE),
                read32(INTEL_OVERLAY_TEST), read32(INTEL_OVERLAY_STATUS),
                *(((uint32*)gInfo->overlay_registers) + 0x68/4), read32(0x30168),
                read32(0x2024));
}


static void
show_overlay(void)
{
        if (gInfo->shared_info->overlay_active
                || gInfo->shared_info->device_type.IsModel(INTEL_MODEL_965))
                return;

        gInfo->shared_info->overlay_active = true;
        gInfo->overlay_registers->overlay_enabled = true;

        QueueCommands queue(gInfo->shared_info->primary_ring_buffer);
        queue.PutOverlayFlip(COMMAND_OVERLAY_ON, true);
        queue.PutFlush();

        TRACE("%s: UP: %lx, TST: %lx, ST: %lx, CMD: %lx (%lx), ERR: %lx\n",
                __func__, read32(INTEL_OVERLAY_UPDATE),
                read32(INTEL_OVERLAY_TEST), read32(INTEL_OVERLAY_STATUS),
                *(((uint32*)gInfo->overlay_registers) + 0x68/4),
                read32(0x30168), read32(0x2024));
}


static void
hide_overlay(void)
{
        if (!gInfo->shared_info->overlay_active
                || gInfo->shared_info->device_type.IsModel(INTEL_MODEL_965))
                return;

        overlay_registers* registers = gInfo->overlay_registers;

        gInfo->shared_info->overlay_active = false;
        registers->overlay_enabled = false;

        QueueCommands queue(gInfo->shared_info->primary_ring_buffer);

        // flush pending commands
        queue.PutFlush();
        queue.PutWaitFor(COMMAND_WAIT_FOR_OVERLAY_FLIP);

        // clear overlay enabled bit
        queue.PutOverlayFlip(COMMAND_OVERLAY_CONTINUE, false);
        queue.PutWaitFor(COMMAND_WAIT_FOR_OVERLAY_FLIP);

        // turn off overlay engine
        queue.PutOverlayFlip(COMMAND_OVERLAY_OFF, false);
        queue.PutWaitFor(COMMAND_WAIT_FOR_OVERLAY_FLIP);

        gInfo->current_overlay = NULL;
}


//      #pragma mark -


uint32
intel_overlay_count(const display_mode* mode)
{
        // TODO: make this depending on the amount of RAM and the screen mode
        // (and we could even have more than one when using 3D as well)
        return 1;
}


const uint32*
intel_overlay_supported_spaces(const display_mode* mode)
{
        static const uint32 kSupportedSpaces[] = {B_RGB15, B_RGB16, B_RGB32,
                B_YCbCr422, 0};
        static const uint32 kSupportedi965Spaces[] = {B_YCbCr422, 0};
        intel_shared_info &sharedInfo = *gInfo->shared_info;

        if (sharedInfo.device_type.InGroup(INTEL_GROUP_96x))
                return kSupportedi965Spaces;

        return kSupportedSpaces;
}


uint32
intel_overlay_supported_features(uint32 colorSpace)
{
        return B_OVERLAY_COLOR_KEY
                | B_OVERLAY_HORIZONTAL_FILTERING
                | B_OVERLAY_VERTICAL_FILTERING
                | B_OVERLAY_HORIZONTAL_MIRRORING;
}


const overlay_buffer* 
intel_allocate_overlay_buffer(color_space colorSpace, uint16 width,
        uint16 height)
{
        TRACE("%s(width %u, height %u, colorSpace %lu)\n", __func__, width,
                height, colorSpace);

        intel_shared_info &sharedInfo = *gInfo->shared_info;
        uint32 bytesPerPixel;

        switch (colorSpace) {
                case B_RGB15:
                        bytesPerPixel = 2;
                        break;
                case B_RGB16:
                        bytesPerPixel = 2;
                        break;
                case B_RGB32:
                        bytesPerPixel = 4;
                        break;
                case B_YCbCr422:
                        bytesPerPixel = 2;
                        break;
                default:
                        return NULL;
        }

        struct overlay* overlay = (struct overlay*)malloc(sizeof(struct overlay));
        if (overlay == NULL)
                return NULL;

        // TODO: locking!

        // alloc graphics mem

        int32 alignment = 0x3f;
        if (sharedInfo.device_type.IsModel(INTEL_MODEL_965))
                alignment = 0xff;

        overlay_buffer* buffer = &overlay->buffer;
        buffer->space = colorSpace;
        buffer->width = width;
        buffer->height = height;
        buffer->bytes_per_row = (width * bytesPerPixel + alignment) & ~alignment;

        status_t status = intel_allocate_memory(buffer->bytes_per_row * height,
                0, overlay->buffer_base);
        if (status < B_OK) {
                free(overlay);
                return NULL;
        }

        if (sharedInfo.device_type.IsModel(INTEL_MODEL_965)) {
                status = intel_allocate_memory(INTEL_i965_OVERLAY_STATE_SIZE,
                        B_APERTURE_NON_RESERVED, overlay->state_base);
                if (status < B_OK) {
                        intel_free_memory(overlay->buffer_base);
                        free(overlay);
                        return NULL;
                }

                overlay->state_offset = overlay->state_base
                        - (addr_t)gInfo->shared_info->graphics_memory;
        }

        overlay->buffer_offset = overlay->buffer_base
                - (addr_t)gInfo->shared_info->graphics_memory;

        buffer->buffer = (uint8*)overlay->buffer_base;
        buffer->buffer_dma = (uint8*)gInfo->shared_info->physical_graphics_memory
                + overlay->buffer_offset;

        TRACE("%s: base=%x, offset=%x, address=%x, physical address=%x\n",
                __func__, overlay->buffer_base, overlay->buffer_offset,
                buffer->buffer, buffer->buffer_dma);

        return buffer;
}


status_t
intel_release_overlay_buffer(const overlay_buffer* buffer)
{
        CALLED();

        struct overlay* overlay = (struct overlay*)buffer;

        // TODO: locking!

        if (gInfo->current_overlay == overlay)
                hide_overlay();

        intel_free_memory(overlay->buffer_base);
        if (gInfo->shared_info->device_type.IsModel(INTEL_MODEL_965))
                intel_free_memory(overlay->state_base);
        free(overlay);

        return B_OK;
}


status_t
intel_get_overlay_constraints(const display_mode* mode,
        const overlay_buffer* buffer, overlay_constraints* constraints)
{
        CALLED();

        // taken from the Radeon driver...

        // scaler input restrictions
        // TODO: check all these values; most of them are probably too restrictive

        // position
        constraints->view.h_alignment = 0;
        constraints->view.v_alignment = 0;

        // alignment
        switch (buffer->space) {
                case B_RGB15:
                        constraints->view.width_alignment = 7;
                        break;
                case B_RGB16:
                        constraints->view.width_alignment = 7;
                        break;
                case B_RGB32:
                        constraints->view.width_alignment = 3;
                        break;
                case B_YCbCr422:
                        constraints->view.width_alignment = 7;
                        break;
                case B_YUV12:
                        constraints->view.width_alignment = 7;
                        break;
                default:
                        return B_BAD_VALUE;
        }
        constraints->view.height_alignment = 0;

        // size
        constraints->view.width.min = 4;                // make 4-tap filter happy
        constraints->view.height.min = 4;
        constraints->view.width.max = buffer->width;
        constraints->view.height.max = buffer->height;

        // scaler output restrictions
        constraints->window.h_alignment = 0;
        constraints->window.v_alignment = 0;
        constraints->window.width_alignment = 0;
        constraints->window.height_alignment = 0;
        constraints->window.width.min = 2;
        constraints->window.width.max = mode->virtual_width;
        constraints->window.height.min = 2;
        constraints->window.height.max = mode->virtual_height;

        // TODO: the minimum values are not tested
        constraints->h_scale.min = 1.0f / (1 << 4);
        constraints->h_scale.max = buffer->width * 7;
        constraints->v_scale.min = 1.0f / (1 << 4);
        constraints->v_scale.max = buffer->height * 7;

        return B_OK;
}


overlay_token
intel_allocate_overlay(void)
{
        CALLED();

        // we only have a single overlay channel
        if (atomic_or(&gInfo->shared_info->overlay_channel_used, 1) != 0)
                return NULL;

        return (overlay_token)++gInfo->shared_info->overlay_token;
}


status_t
intel_release_overlay(overlay_token overlayToken)
{
        CALLED();

        // we only have a single token, which simplifies this
        if (overlayToken != (overlay_token)gInfo->shared_info->overlay_token)
                return B_BAD_VALUE;

        atomic_and(&gInfo->shared_info->overlay_channel_used, 0);

        return B_OK;
}


status_t
intel_configure_overlay(overlay_token overlayToken,
        const overlay_buffer* buffer, const overlay_window* window,
        const overlay_view* view)
{
        CALLED();

        if (overlayToken != (overlay_token)gInfo->shared_info->overlay_token)
                return B_BAD_VALUE;

        if (window == NULL || view == NULL) {
                hide_overlay();
                return B_OK;
        }

        struct overlay* overlay = (struct overlay*)buffer;
        overlay_registers* registers = gInfo->overlay_registers;
        intel_shared_info &sharedInfo = *gInfo->shared_info;
        bool updateCoefficients = false;
        uint32 bytesPerPixel = 2;

        switch (buffer->space) {
                case B_RGB15:
                        registers->source_format = OVERLAY_FORMAT_RGB15;
                        break;
                case B_RGB16:
                        registers->source_format = OVERLAY_FORMAT_RGB16;
                        break;
                case B_RGB32:
                        registers->source_format = OVERLAY_FORMAT_RGB32;
                        bytesPerPixel = 4;
                        break;
                case B_YCbCr422:
                        registers->source_format = OVERLAY_FORMAT_YCbCr422;
                        break;
        }

        if (!gInfo->shared_info->overlay_active
                || memcmp(&gInfo->last_overlay_view, view, sizeof(overlay_view)) != 0
                || memcmp(&gInfo->last_overlay_frame, window, sizeof(overlay_frame)) != 0) {
                // scaling has changed, program window and scaling factor

                // clip the window to on screen bounds
                // TODO: this is not yet complete or correct - especially if we start
                // to support moving the display!
                int32 left, top, right, bottom;
                left = window->h_start;
                right = window->h_start + window->width;
                top = window->v_start;
                bottom = window->v_start + window->height;
                if (left < 0)
                        left = 0;
                if (top < 0)
                        top = 0;
                if (right > sharedInfo.current_mode.timing.h_display)
                        right = sharedInfo.current_mode.timing.h_display;
                if (bottom > sharedInfo.current_mode.timing.v_display)
                        bottom = sharedInfo.current_mode.timing.v_display;
                if (left >= right || top >= bottom) {
                        // overlay is not within visible bounds
                        hide_overlay();
                        return B_OK;
                }

                registers->window_left = left;
                registers->window_top = top;
                registers->window_width = right - left;
                registers->window_height = bottom - top;

                uint32 horizontalScale = (view->width << 12) / window->width;
                uint32 verticalScale = (view->height << 12) / window->height;
                uint32 horizontalScaleUV = horizontalScale >> 1;
                uint32 verticalScaleUV = verticalScale >> 1;
                horizontalScale = horizontalScaleUV << 1;
                verticalScale = verticalScaleUV << 1;

                // we need to offset the overlay view to adapt it to the clipping
                // (in addition to whatever offset is desired already)
                left = view->h_start - (int32)((window->h_start - left)
                        * (horizontalScale / 4096.0) + 0.5);
                top = view->v_start - (int32)((window->v_start - top)
                        * (verticalScale / 4096.0) + 0.5);
                right = view->h_start + view->width;
                bottom = view->v_start + view->height;

                gInfo->overlay_position_buffer_offset = buffer->bytes_per_row * top
                        + left * bytesPerPixel;

                // Note: in non-planar mode, you *must* not program the source
                // width/height UV registers - they must stay cleared, or the chip is
                // doing strange stuff.
                // On the other hand, you have to program the UV scaling registers, or
                // the result will be wrong, too.
                registers->source_width_rgb = right - left;
                registers->source_height_rgb = bottom - top;
                if (gInfo->shared_info->device_type.InFamily(INTEL_FAMILY_8xx)) {
                        registers->source_bytes_per_row_rgb = (((overlay->buffer_offset
                                + (view->width << 1) + 0x1f) >> 5)
                                - (overlay->buffer_offset >> 5) - 1) << 2;
                } else {
                        int yaddress = overlay->buffer_offset;
                        int yswidth = view->width << 1;
                        registers->source_bytes_per_row_rgb = (((((yaddress
                                + yswidth + 0x3f) >> 6) - (yaddress >> 6)) << 1) - 1) << 2;
                }

                // horizontal scaling
                registers->scale_rgb.horizontal_downscale_factor
                        = horizontalScale >> 12;
                registers->scale_rgb.horizontal_scale_fraction
                        = horizontalScale & 0xfff;
                registers->scale_uv.horizontal_downscale_factor
                        = horizontalScaleUV >> 12;
                registers->scale_uv.horizontal_scale_fraction
                        = horizontalScaleUV & 0xfff;

                // vertical scaling
                registers->scale_rgb.vertical_scale_fraction = verticalScale & 0xfff;
                registers->scale_uv.vertical_scale_fraction = verticalScaleUV & 0xfff;
                registers->vertical_scale_rgb = verticalScale >> 12;
                registers->vertical_scale_uv = verticalScaleUV >> 12;

                TRACE("scale: h = %ld.%ld, v = %ld.%ld\n", horizontalScale >> 12,
                        horizontalScale & 0xfff, verticalScale >> 12,
                        verticalScale & 0xfff);

                if (verticalScale != gInfo->last_vertical_overlay_scale
                        || horizontalScale != gInfo->last_horizontal_overlay_scale) {
                        // Recompute phase coefficients (taken from X driver)
                        updateCoefficients = true;

                        phase_coefficient coefficients[NUM_HORIZONTAL_TAPS * NUM_PHASES];
                        update_coefficients(NUM_HORIZONTAL_TAPS, horizontalScale / 4096.0,
                                true, true, coefficients);

                        phase_coefficient coefficientsUV[
                                NUM_HORIZONTAL_UV_TAPS * NUM_PHASES];
                        update_coefficients(NUM_HORIZONTAL_UV_TAPS,
                                horizontalScaleUV / 4096.0, true, false, coefficientsUV);

                        int32 pos = 0;
                        for (int32 i = 0; i < NUM_PHASES; i++) {
                                for (int32 j = 0; j < NUM_HORIZONTAL_TAPS; j++) {
                                        registers->horizontal_coefficients_rgb[pos]
                                                = coefficients[pos].sign << 15
                                                        | coefficients[pos].exponent << 12
                                                        | coefficients[pos].mantissa;
                                        pos++;
                                }
                        }

                        pos = 0;
                        for (int32 i = 0; i < NUM_PHASES; i++) {
                                for (int32 j = 0; j < NUM_HORIZONTAL_UV_TAPS; j++) {
                                        registers->horizontal_coefficients_uv[pos]
                                                = coefficientsUV[pos].sign << 15
                                                        | coefficientsUV[pos].exponent << 12
                                                        | coefficientsUV[pos].mantissa;
                                        pos++;
                                }
                        }

                        gInfo->last_vertical_overlay_scale = verticalScale;
                        gInfo->last_horizontal_overlay_scale = horizontalScale;
                }

                gInfo->last_overlay_view = *view;
                gInfo->last_overlay_frame = *(overlay_frame*)window;
        }

        registers->color_control_output_mode = true;
        registers->select_pipe = 0;

        // program buffer

        registers->buffer_rgb0
                = overlay->buffer_offset + gInfo->overlay_position_buffer_offset;
        registers->stride_rgb = buffer->bytes_per_row;

        registers->mirroring_mode
                = (window->flags & B_OVERLAY_HORIZONTAL_MIRRORING) != 0
                        ? OVERLAY_MIRROR_HORIZONTAL : OVERLAY_MIRROR_NORMAL;
        registers->ycbcr422_order = 0;

        if (!gInfo->shared_info->overlay_active) {
                // overlay is shown for the first time
                set_color_key(window);
                show_overlay();
        } else
                update_overlay(updateCoefficients);

        gInfo->current_overlay = overlay;
        return B_OK;
}