/*
 * Copyright 2012, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *    Alexander von Gluck, kallisti5@unixzen.com
 */


#include "ringqueue.h"

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


#define TRACE_RENDER_QUEUE
#ifdef TRACE_RENDER_QUEUE
extern "C" void _sPrintf(const char* format, ...);
#   define TRACE(x...) _sPrintf("radeon_hd: " x)
#else
#   define TRACE(x...) ;
#endif

#define ERROR(x...) _sPrintf("radeon_hd: " x)


static const char* queueName[RADEON_QUEUE_MAX] = {
    "GFX",
    "CP1",
    "CP2"
};


int
compute_order(unsigned long size)
{
        int     order;
        unsigned long tmp;
        for (order = 0, tmp = size; tmp >>= 1; ++order);

        if (size & ~(1 << order))
                ++order;

        return order;
}


RingQueue::RingQueue(size_t sizeBytes, uint32 queueType)
        :
        fQueueType(queueType),
        fReadPtr(0),
        fWritePtr(0)
{
        TRACE("%s: Requested %d bytes for %s RingQueue.\n", __func__, sizeBytes,
                queueName[fQueueType]);

        size_t renderQueueSize = compute_order(sizeBytes / 8);
        fSize = (1 << (renderQueueSize + 1)) * 4;
        fWriteBytesAvail = fSize;
        fAlignMask = 16 - 1;

        TRACE("%s: Allocating %d bytes for %s RingQueue.\n", __func__, fSize,
                queueName[fQueueType]);

        // Allocate buffer memory
        fData = (unsigned char*)malloc(fSize);
        // Clear buffer
        memset(fData, 0, fSize);
}


RingQueue::~RingQueue()
{
        TRACE("%s: Closing %s RingQueue.\n", __func__, queueName[fQueueType]);
        free(fData);
}


status_t
RingQueue::Empty()
{
        TRACE("%s: Clearing %s RingQueue\n", __func__, queueName[fQueueType]);
        // Clear buffer
        memset(fData, 0, fSize);

        // Reset counters
        fReadPtr = 0;
        fWritePtr = 0;
        fWriteBytesAvail = fSize;
        return B_OK;
}


size_t
RingQueue::Read(unsigned char* dataPtr, size_t bytes)
{
        // If there is no data or nothing to read, return 0 bytes
        if (dataPtr == 0 || bytes <= 0 || fWriteBytesAvail == fSize)
                return 0;

        size_t readBytesAvail = fSize - fWriteBytesAvail;

        // Set a high threshold of total available bytes available.
        if (bytes > readBytesAvail)
                bytes = readBytesAvail;

        // Keep track of position and pull needed data
        if (bytes > fSize - fReadPtr) {
                size_t len = fSize - fReadPtr;
                memcpy(dataPtr, fData + fReadPtr, len);
                memcpy(dataPtr + len, fData, bytes - len);
        } else {
                memcpy(dataPtr, fData + fReadPtr, bytes);
        }

        fReadPtr = (fReadPtr + bytes) % fSize;
        fWriteBytesAvail += bytes;

        return bytes;
}


size_t
RingQueue::Write(unsigned char* dataPtr, size_t bytes)
{
        // If there is no data, or no room available, 0 bytes written.
        if (dataPtr == 0 || bytes <= 0 || fWriteBytesAvail == 0)
                return 0;

        // Set a high threshold of the number of bytes available.
        if (bytes > fWriteBytesAvail)
                bytes = fWriteBytesAvail;

        // Keep track of position and push needed data
        if (bytes > fSize - fWritePtr) {
                size_t len = fSize - fWritePtr;
                memcpy(fData + fWritePtr, dataPtr, len);
                memcpy(fData, dataPtr + len, bytes - len);
        } else
                memcpy(fData + fWritePtr, dataPtr, bytes);

        fWritePtr = (fWritePtr + bytes) % fSize;
        fWriteBytesAvail -= bytes;

        return bytes;
}