/*
 * Copyright 2010 Haiku, Inc.  All rights reserved.
 * Distributed under the terms of the MIT license.
 *
 * Authors:
 *              Gerald Zajac
 */

#include "accelerant.h"
#include "3dfx.h"



bool
TDFX_DisplayOverlay(const overlay_window* window,
                                                const overlay_buffer* buffer,
                                                const overlay_view* view)
{
        // Return true if setup is successful.

        SharedInfo& si = *gInfo.sharedInfo;

        if (window == NULL || buffer == NULL || view == NULL)
                return false;

        if (window->flags & B_OVERLAY_COLOR_KEY) {
                uint32 color = 0;

                if (si.displayMode.bitsPerPixel == 16) {
                        color = (window->blue.value & window->blue.mask) << 0
                                  | (window->green.value & window->green.mask) << 5
                                  | (window->red.value & window->red.mask) << 11;
                                  // 16 bit color has no alpha bits
                } else {
                        color = (window->blue.value & window->blue.mask) << 0
                                  | (window->green.value & window->green.mask) << 8
                                  | (window->red.value & window->red.mask) << 16
                                  | (window->alpha.value & window->alpha.mask) << 24;
                }

                TDFX_WaitForFifo(2);
                OUTREG32(VIDEO_CHROMA_MIN, color);
                OUTREG32(VIDEO_CHROMA_MAX, color);
        }

        uint32 videoConfig = INREG32(VIDEO_PROC_CONFIG);
        videoConfig &= ~VIDEO_PROC_CONFIG_MASK;
        videoConfig |= (0x00000320 | OVERLAY_CLUT_BYPASS);

        // Scale image if window dimension is larger than the buffer dimension.
        // Scaling is not done if window dimension is smaller since the chip only
        // scales up to a larger dimension, and does not scale down to a smaller
        // dimension.

        if (window->width > buffer->width)
                videoConfig |= (1 << 14);
        if (window->height > buffer->height)
                videoConfig |= (1 << 15);

        switch (buffer->space) {
                case B_YCbCr422:
                        videoConfig |= VIDCFG_OVL_FMT_YUYV422;
                        break;
                case B_RGB16:
                        videoConfig |= VIDCFG_OVL_FMT_RGB565;
                        break;
                default:
                        return false;   // color space not supported
        }

        // can't do bilinear filtering when in 2X mode
        if ((videoConfig & VIDEO_2X_MODE_ENABLE) == 0)
                videoConfig |= (3 << 16);

        TDFX_WaitForFifo(1);
        OUTREG32(VIDEO_PROC_CONFIG, videoConfig);

        // Subtract 1 from height to eliminate junk on last line of image.
        int32 dudx = (buffer->width << 20) / window->width;
        int32 dudy = ((buffer->height - 1) << 20) / window->height;

        int32 x1 = (window->h_start < 0) ? 0 : window->h_start;
        int32 y1 = (window->v_start < 0) ? 0 : window->v_start;

        int32 x2 = x1 + window->width - 1;
        int32 y2 = y1 + window->height - 1;

        TDFX_WaitForFifo(6);

        // Set up coordinates of overlay window on screen.
        OUTREG32(VIDEO_OVERLAY_START_COORDS, x1 | (y1 << 12));
        OUTREG32(VIDEO_OVERLAY_END_COORDS, x2 | (y2 << 12));
        // Set up scale and position of overlay in graphics memory.
        OUTREG32(VIDEO_OVERLAY_DUDX, dudx);
        OUTREG32(VIDEO_OVERLAY_DUDX_OFFSET_SRC_WIDTH, ((x1 & 0x0001ffff) << 3)
                | (buffer->width << 20));
        OUTREG32(VIDEO_OVERLAY_DVDY, dudy);
        OUTREG32(VIDEO_OVERLAY_DVDY_OFFSET, (y1 & 0x0000ffff) << 3);

        // Add width of overlay buffer to stride.
        uint32 stride = INREG32(VIDEO_DESKTOP_OVERLAY_STRIDE) & 0x0000ffff;
        stride |= (buffer->width << 1) << 16;
        uint32 offset = (uint32)(addr_t)buffer->buffer_dma;

        TDFX_WaitForFifo(2);

        OUTREG32(VIDEO_DESKTOP_OVERLAY_STRIDE, stride);
        OUTREG32(VIDEO_IN_ADDR0, offset);

        return true;
}


void
TDFX_StopOverlay(void)
{
        // reset the video
        uint32 videoConfig = INREG32(VIDEO_PROC_CONFIG) & ~VIDEO_PROC_CONFIG_MASK;
        OUTREG32(VIDEO_PROC_CONFIG, videoConfig);
        OUTREG32(RGB_MAX_DELTA, 0x0080808);
}