pvrqwsdrawable.h File Reference

Go to the source code of this file.

Classes
struct	PvrQwsRect

Typedefs
typedef struct _PvrQwsDrawable	PvrQwsDrawable
typedef void(*	PvrQwsSwapFunction) (PvrQwsDrawable *drawable, void *userData, int repaintOnly)

Enumerations
enum	PvrQwsDrawableType { PvrQwsScreen, PvrQwsWindow, PvrQwsPixmap }
enum	PvrQwsPixelFormat {   PvrQws_1BPP = 0, PvrQws_RGB565, PvrQws_ARGB4444, PvrQws_RGB888,   PvrQws_ARGB8888, PvrQws_VGAEMU }

Functions
int	pvrQwsAllocBuffers (PvrQwsDrawable *drawable)
void	pvrQwsClearVisibleRegion (PvrQwsDrawable *drawable)
PvrQwsDrawable *	pvrQwsCreatePixmap (int width, int height, int screen)
PvrQwsDrawable *	pvrQwsCreateWindow (int screen, long winId, const PvrQwsRect *rect)
void	pvrQwsDestroyDrawable (PvrQwsDrawable *drawable)
void	pvrQwsDisplayClose (void)
int	pvrQwsDisplayIsOpen (void)
int	pvrQwsDisplayOpen (void)
PvrQwsDrawable *	pvrQwsFetchWindow (long winId)
void	pvrQwsFreeBuffers (PvrQwsDrawable *drawable)
PvrQwsDrawableType	pvrQwsGetDrawableType (PvrQwsDrawable *drawable)
void	pvrQwsGetGeometry (PvrQwsDrawable *drawable, PvrQwsRect *rect)
PvrQwsPixelFormat	pvrQwsGetPixelFormat (PvrQwsDrawable *drawable)
void *	pvrQwsGetRenderBuffer (PvrQwsDrawable *drawable)
int	pvrQwsGetStride (PvrQwsDrawable *drawable)
void	pvrQwsInvalidateBuffers (PvrQwsDrawable *drawable)
int	pvrQwsReleaseWindow (PvrQwsDrawable *drawable)
PvrQwsDrawable *	pvrQwsScreenWindow (int screen)
void	pvrQwsSetGeometry (PvrQwsDrawable *drawable, const PvrQwsRect *rect)
void	pvrQwsSetRotation (PvrQwsDrawable *drawable, int angle)
void	pvrQwsSetSwapFunction (PvrQwsDrawable *drawable, PvrQwsSwapFunction func, void *userData)
void	pvrQwsSetVisibleRegion (PvrQwsDrawable *drawable, const PvrQwsRect *rects, int numRects)
int	pvrQwsSwapBuffers (PvrQwsDrawable *drawable, int repaintOnly)

Typedef Documentation

PvrQwsDrawable

typedef struct _PvrQwsDrawable PvrQwsDrawable

Definition at line 72 of file pvrqwsdrawable.h.

PvrQwsSwapFunction

typedef void(* PvrQwsSwapFunction) (PvrQwsDrawable *drawable, void *userData, int repaintOnly)

Definition at line 75 of file pvrqwsdrawable.h.

Enumeration Type Documentation

PvrQwsDrawableType

enum PvrQwsDrawableType

Enumerator
PvrQwsScreen
PvrQwsWindow
PvrQwsPixmap

Definition at line 53 of file pvrqwsdrawable.h.

{
    PvrQwsScreen,
    PvrQwsWindow,
    PvrQwsPixmap

} PvrQwsDrawableType;

PvrQwsPixelFormat

enum PvrQwsPixelFormat

Enumerator
PvrQws_1BPP
PvrQws_RGB565
PvrQws_ARGB4444
PvrQws_RGB888
PvrQws_ARGB8888
PvrQws_VGAEMU

Definition at line 61 of file pvrqwsdrawable.h.

{
    PvrQws_1BPP = 0,
    PvrQws_RGB565,
    PvrQws_ARGB4444,
    PvrQws_RGB888,
    PvrQws_ARGB8888,
    PvrQws_VGAEMU

} PvrQwsPixelFormat;

Function Documentation

pvrQwsAllocBuffers()

int pvrQwsAllocBuffers

(

PvrQwsDrawable *

drawable

)

Definition at line 651 of file pvrqwsdrawable.c.

Referenced by wseglCreatePixmapDrawable(), and wseglCreateWindowDrawable().

{
    int index;
    int numBuffers = PVRQWS_MAX_BACK_BUFFERS;
    if (drawable->type == PvrQwsPixmap)
        numBuffers = 1;
    if (drawable->backBuffers[0]) {
        if (drawable->backBuffersValid)
            return 1;
        if (!drawable->usingFlipBuffers) {
            for (index = 0; index < numBuffers; ++index)
                PVR2DMemFree(pvrQwsDisplay.context, drawable->backBuffers[index]);
        }
    }
    drawable->stridePixels = (drawable->rect.width + 31) & ~31;
    drawable->strideBytes =
        drawable->stridePixels *
        pvrQwsDisplay.screens[drawable->screen].bytesPerPixel;
    drawable->usingFlipBuffers =
        (pvrQwsDisplay.numFlipBuffers > 0 && drawable->isFullScreen);
    if (drawable->usingFlipBuffers) {
        if (numBuffers > (int)(pvrQwsDisplay.numFlipBuffers))
            numBuffers = pvrQwsDisplay.numFlipBuffers;
        for (index = 0; index < numBuffers; ++index)
            drawable->backBuffers[index] = pvrQwsDisplay.flipBuffers[index];
    } else {
        for (index = 0; index < numBuffers; ++index) {
            if (PVR2DMemAlloc(pvrQwsDisplay.context,
                              drawable->strideBytes * drawable->rect.height,
                              128, 0,
                              &(drawable->backBuffers[index])) != PVR2D_OK) {
                while (--index >= 0)
                    PVR2DMemFree(pvrQwsDisplay.context, drawable->backBuffers[index]);
                memset(drawable->backBuffers, 0, sizeof(drawable->backBuffers));
                drawable->backBuffersValid = 0;
                return 0;
            }
        }
    }
    for (index = numBuffers; index < PVRQWS_MAX_BACK_BUFFERS; ++index) {
        drawable->backBuffers[index] = drawable->backBuffers[0];
    }
    drawable->backBuffersValid = 1;
    drawable->currentBackBuffer = 0;
    return 1;
}

pvrQwsClearVisibleRegion()

void pvrQwsClearVisibleRegion

(

PvrQwsDrawable *

drawable

)

Definition at line 583 of file pvrqwsdrawable.c.

Referenced by PvrEglWindowSurface::setDirectRegion().

{
    if (drawable->type != PvrQwsPixmap)
        drawable->numVisibleRects = 0;
}

pvrQwsCreatePixmap()

PvrQwsDrawable* pvrQwsCreatePixmap	(	int	width,
		int	height,
		int	screen
	)

Definition at line 465 of file pvrqwsdrawable.c.

{
    PvrQwsDrawable *drawable;

    if (!pvrQwsEnsureScreen(screen))
        return 0;

    drawable = (PvrQwsDrawable *)calloc(1, sizeof(PvrQwsDrawable));
    if (!drawable)
        return 0;

    drawable->type = PvrQwsPixmap;
    drawable->screen = screen;
    drawable->pixelFormat = pvrQwsDisplay.screens[screen].pixelFormat;
    drawable->rect.x = 0;
    drawable->rect.y = 0;
    drawable->rect.width = width;
    drawable->rect.height = height;

    if (!pvrQwsAddDrawable()) {
        free(drawable);
        return 0;
    }

    return drawable;
}

pvrQwsCreateWindow()

PvrQwsDrawable* pvrQwsCreateWindow	(	int	screen,
		long	winId,
		const PvrQwsRect *	rect
	)

Definition at line 417 of file pvrqwsdrawable.c.

Referenced by PvrEglWindowSurface::PvrEglWindowSurface().

{
    PvrQwsDrawable *drawable;

    if (!pvrQwsEnsureScreen(screen))
        return 0;

    drawable = (PvrQwsDrawable *)calloc(1, sizeof(PvrQwsDrawable));
    if (!drawable)
        return 0;

    drawable->type = PvrQwsWindow;
    drawable->winId = winId;
    drawable->refCount = 1;
    drawable->screen = screen;
    drawable->pixelFormat = pvrQwsDisplay.screens[screen].pixelFormat;
    drawable->rect = *rect;

    if (!pvrQwsAddDrawable()) {
        free(drawable);
        return 0;
    }

    drawable->nextWinId = pvrQwsDisplay.firstWinId;
    pvrQwsDisplay.firstWinId = drawable;

    return drawable;
}

pvrQwsDestroyDrawable()

void pvrQwsDestroyDrawable

(

PvrQwsDrawable *

drawable

)

Definition at line 516 of file pvrqwsdrawable.c.

Referenced by wseglDeleteDrawable(), and PvrEglWindowSurface::~PvrEglWindowSurface().

{
    if (drawable && drawable->type != PvrQwsScreen)
        pvrQwsDestroyDrawableForced(drawable);
}

pvrQwsDisplayClose()

void pvrQwsDisplayClose

(

void

)

Definition at line 338 of file pvrqwsdrawable.c.

Referenced by PvrEglScreen::connect(), PvrEglScreen::disconnect(), wseglCloseDisplay(), and wseglInitializeDisplay().

{
    int screen;

    if (pvrQwsDisplay.refCount == 0)
        return;
    if (--(pvrQwsDisplay.refCount) > 0)
        return;

    /* Prevent pvrQwsDestroyContext from being called for the time being */
    ++pvrQwsDisplay.numDrawables;

    /* Free the screens */
    for (screen = 0; screen < PVRQWS_MAX_SCREENS; ++screen) {
        PvrQwsScreenInfo *info = &(pvrQwsDisplay.screens[screen]);
        if (info->screenDrawable)
            pvrQwsDestroyDrawableForced(info->screenDrawable);
        if (info->frameBuffer)
            PVR2DMemFree(pvrQwsDisplay.context, info->frameBuffer);
        if (info->mapped && info->needsUnmap)
            munmap(info->mapped, info->mappedLength);
    }

    /* Now it is safe to destroy the PVR2D context */
    --pvrQwsDisplay.numDrawables;
    if (pvrQwsDisplay.context)
        PVR2DDestroyDeviceContext(pvrQwsDisplay.context);

    memset(&pvrQwsDisplay, 0, sizeof(pvrQwsDisplay));
}

pvrQwsDisplayIsOpen()

int pvrQwsDisplayIsOpen

(

void

)

Definition at line 369 of file pvrqwsdrawable.c.

{
    return (pvrQwsDisplay.refCount > 0);
}

pvrQwsDisplayOpen()

int pvrQwsDisplayOpen

(

void

)

Definition at line 313 of file pvrqwsdrawable.c.

Referenced by PvrEglScreen::connect(), and wseglInitializeDisplay().

{
    int screen;

    /* If the display is already open, increase reference count and return */
    if (pvrQwsDisplay.refCount > 0) {
        ++(pvrQwsDisplay.refCount);
        return 1;
    }

    /* Open the framebuffer and map it directly */
    if (!pvrQwsInitFbScreen(0)) {
        --(pvrQwsDisplay.refCount);
        return 0;
    }

    /* Clear the other screens.  We will create them if they are referenced */
    for (screen = 1; screen < PVRQWS_MAX_SCREENS; ++screen)
        memset(&(pvrQwsDisplay.screens[screen]), 0, sizeof(PvrQwsScreenInfo));

    /* The display is open and ready */
    ++(pvrQwsDisplay.refCount);
    return 1;
}

pvrQwsFetchWindow()

PvrQwsDrawable* pvrQwsFetchWindow

(

long

winId

)

Definition at line 446 of file pvrqwsdrawable.c.

Referenced by PvrEglWindowSurface::PvrEglWindowSurface(), and wseglCreateWindowDrawable().

{
    PvrQwsDrawable *drawable = pvrQwsDisplay.firstWinId;
    while (drawable != 0 && drawable->winId != winId)
        drawable = drawable->nextWinId;

    if (drawable)
        ++(drawable->refCount);
    return drawable;
}

pvrQwsFreeBuffers()

void pvrQwsFreeBuffers

(

PvrQwsDrawable *

drawable

)

Definition at line 698 of file pvrqwsdrawable.c.

Referenced by pvrQwsDestroyDrawableForced(), and wseglDeleteDrawable().

{
    int index;
    int numBuffers = PVRQWS_MAX_BACK_BUFFERS;
    if (drawable->type == PvrQwsPixmap)
        numBuffers = 1;
    if (!drawable->usingFlipBuffers) {
        for (index = 0; index < numBuffers; ++index) {
            if (drawable->backBuffers[index])
                PVR2DMemFree(pvrQwsDisplay.context, drawable->backBuffers[index]);
        }
    }
    memset(drawable->backBuffers, 0, sizeof(drawable->backBuffers));
    drawable->backBuffersValid = 0;
    drawable->usingFlipBuffers = 0;
}

pvrQwsGetDrawableType()

PvrQwsDrawableType pvrQwsGetDrawableType

(

PvrQwsDrawable *

drawable

)

Definition at line 522 of file pvrqwsdrawable.c.

{
    return drawable->type;
}

pvrQwsGetGeometry()

void pvrQwsGetGeometry	(	PvrQwsDrawable *	drawable,
		PvrQwsRect *	rect
	)

Definition at line 615 of file pvrqwsdrawable.c.

Referenced by PvrEglWindowSurface::image().

{
    *rect = drawable->rect;
}

pvrQwsGetPixelFormat()

PvrQwsPixelFormat pvrQwsGetPixelFormat

(

PvrQwsDrawable *

drawable

)

Definition at line 638 of file pvrqwsdrawable.c.

{
    return (PvrQwsPixelFormat)(drawable->pixelFormat);
}

pvrQwsGetRenderBuffer()

void* pvrQwsGetRenderBuffer

(

PvrQwsDrawable *

drawable

)

Definition at line 643 of file pvrqwsdrawable.c.

Referenced by PvrEglWindowSurface::image().

{
    if (drawable->backBuffersValid)
        return drawable->backBuffers[drawable->currentBackBuffer]->pBase;
    else
        return 0;
}

pvrQwsGetStride()

int pvrQwsGetStride

(

PvrQwsDrawable *

drawable

)

Definition at line 630 of file pvrqwsdrawable.c.

Referenced by PvrEglWindowSurface::image().

{
    if (drawable->backBuffersValid)
        return drawable->strideBytes;
    else
        return 0;
}

pvrQwsInvalidateBuffers()

void pvrQwsInvalidateBuffers

(

PvrQwsDrawable *

drawable

)

Definition at line 715 of file pvrqwsdrawable.c.

Referenced by pvrQwsSetGeometry(), and pvrQwsSetRotation().

{
    drawable->backBuffersValid = 0;
}

pvrQwsReleaseWindow()

int pvrQwsReleaseWindow

(

PvrQwsDrawable *

drawable

)

Definition at line 457 of file pvrqwsdrawable.c.

Referenced by wseglDeleteDrawable(), and PvrEglWindowSurface::~PvrEglWindowSurface().

{
    if (drawable->type == PvrQwsWindow)
        return (--(drawable->refCount) <= 0);
    else
        return 0;
}

pvrQwsScreenWindow()

PvrQwsDrawable* pvrQwsScreenWindow

(

int

screen

)

Definition at line 384 of file pvrqwsdrawable.c.

Referenced by PvrEglScreen::PvrEglScreen(), and wseglCreateWindowDrawable().

{
    PvrQwsDrawable *drawable;

    if (!pvrQwsEnsureScreen(screen))
        return 0;

    drawable = pvrQwsDisplay.screens[screen].screenDrawable;
    if (drawable)
        return drawable;

    drawable = (PvrQwsDrawable *)calloc(1, sizeof(PvrQwsDrawable));
    if (!drawable)
        return 0;

    drawable->type = PvrQwsScreen;
    drawable->screen = screen;
    drawable->pixelFormat = pvrQwsDisplay.screens[screen].pixelFormat;
    drawable->rect = pvrQwsDisplay.screens[screen].screenRect;
    drawable->visibleRects[0] = drawable->rect;
    drawable->numVisibleRects = 1;
    drawable->isFullScreen = 1;

    if (!pvrQwsAddDrawable()) {
        free(drawable);
        return 0;
    }

    pvrQwsDisplay.screens[screen].screenDrawable = drawable;

    return drawable;
}

pvrQwsSetGeometry()

void pvrQwsSetGeometry	(	PvrQwsDrawable *	drawable,
		const PvrQwsRect *	rect
	)

Definition at line 589 of file pvrqwsdrawable.c.

Referenced by PvrEglWindowSurface::move(), PvrEglWindowSurface::PvrEglWindowSurface(), and PvrEglWindowSurface::setGeometry().

{
    /* We can only change the geometry of window drawables */
    if (drawable->type != PvrQwsWindow)
        return;

    /* If the position has changed, then clear the visible region */
    if (drawable->rect.x != rect->x || drawable->rect.y != rect->y) {
        drawable->rect.x = rect->x;
        drawable->rect.y = rect->y;
        drawable->numVisibleRects = 0;
    }

    /* If the size has changed, then clear the visible region and
       invalidate the drawable's buffers.  Invalidating the buffers
       will force EGL to recreate the drawable, which will then
       allocate new buffers for the new size */
    if (drawable->rect.width != rect->width ||
            drawable->rect.height != rect->height) {
        drawable->rect.width = rect->width;
        drawable->rect.height = rect->height;
        drawable->numVisibleRects = 0;
        pvrQwsInvalidateBuffers(drawable);
    }
}

pvrQwsSetRotation()

void pvrQwsSetRotation	(	PvrQwsDrawable *	drawable,
		int	angle
	)

Definition at line 620 of file pvrqwsdrawable.c.

Referenced by PvrEglWindowSurface::move(), PvrEglWindowSurface::PvrEglWindowSurface(), PvrEglWindowSurface::setDirectRegion(), and PvrEglWindowSurface::setGeometry().

{
    if (drawable->rotationAngle != angle) {
        drawable->rotationAngle = angle;

        /* Force the buffers to be recreated if the rotation angle changes */
        pvrQwsInvalidateBuffers(drawable);
    }
}

pvrQwsSetSwapFunction()

void pvrQwsSetSwapFunction	(	PvrQwsDrawable *	drawable,
		PvrQwsSwapFunction	func,
		void *	userData
	)

Definition at line 826 of file pvrqwsdrawable.c.

Referenced by pvrQwsSwapBuffers().

{
    drawable->swapFunction = func;
    drawable->userData = userData;
}

pvrQwsSetVisibleRegion()

void pvrQwsSetVisibleRegion	(	PvrQwsDrawable *	drawable,
		const PvrQwsRect *	rects,
		int	numRects
	)

Definition at line 528 of file pvrqwsdrawable.c.

Referenced by pvrQwsGetDrawableType(), and PvrEglWindowSurface::setDirectRegion().

{
    int index, indexOut;
    PvrQwsRect *rect;
    PvrQwsRect *screenRect;

    /* Visible regions don't make sense for pixmaps */
    if (drawable->type == PvrQwsPixmap)
        return;

    /* Restrict the number of rectangles to prevent buffer overflow */
    if (numRects > PVRQWS_MAX_VISIBLE_RECTS)
        numRects = PVRQWS_MAX_VISIBLE_RECTS;
    if (numRects > 0)
        memcpy(drawable->visibleRects, rects, numRects * sizeof(PvrQwsRect));

    /* Convert the rectangles into screen-relative co-ordinates and
       then clamp them to the screen boundaries.  If any of the
       clamped rectangles are empty, remove them from the list */
    screenRect = &(pvrQwsDisplay.screens[drawable->screen].screenRect);
    indexOut = 0;
    for (index = 0, rect = drawable->visibleRects; index < numRects; ++index, ++rect) {
        if (rect->x < 0) {
            rect->width += rect->x;
            rect->x = 0;
            if (rect->width < 0)
                rect->width = 0;
        } else if (rect->x >= screenRect->width) {
            rect->x = screenRect->width;
            rect->width = 0;
        }
        if ((rect->x + rect->width) > screenRect->width) {
            rect->width = screenRect->width - rect->x;
        }
        if (rect->y < 0) {
            rect->height += rect->y;
            rect->y = 0;
            if (rect->height < 0)
                rect->height = 0;
        } else if (rect->y >= screenRect->height) {
            rect->y = screenRect->height;
            rect->height = 0;
        }
        if ((rect->y + rect->height) > screenRect->height) {
            rect->height = screenRect->height - rect->y;
        }
        if (rect->width > 0 && rect->height > 0) {
            if (index != indexOut)
                drawable->visibleRects[indexOut] = *rect;
            ++indexOut;
        }
    }
    drawable->numVisibleRects = indexOut;
}

pvrQwsSwapBuffers()

int pvrQwsSwapBuffers	(	PvrQwsDrawable *	drawable,
		int	repaintOnly
	)

Definition at line 732 of file pvrqwsdrawable.c.

Referenced by PvrEglWindowSurface::setDirectRegion(), and wseglSwapDrawable().

{
    PVR2DMEMINFO *buffer;
    PvrQwsRect *rect;
    int index;

    /* Bail out if the back buffers have been invalidated */
    if (!drawable->backBuffersValid)
        return 0;

    /* If there is a swap function, then use that instead */
    if (drawable->swapFunction) {
        (*(drawable->swapFunction))(drawable, drawable->userData, repaintOnly);
        if (!repaintOnly) {
            drawable->currentBackBuffer
                = (drawable->currentBackBuffer + 1) % PVRQWS_MAX_BACK_BUFFERS;
        }
        return 1;
    }

    /* Iterate through the visible rectangles and blit them to the screen */
    if (!repaintOnly) {
        index = drawable->currentBackBuffer;
    } else {
        index = (drawable->currentBackBuffer + PVRQWS_MAX_BACK_BUFFERS - 1)
                        % PVRQWS_MAX_BACK_BUFFERS;
    }
    buffer = drawable->backBuffers[index];
    rect = drawable->visibleRects;
    if (drawable->usingFlipBuffers) {
        PVR2DPresentFlip(pvrQwsDisplay.context, pvrQwsDisplay.flipChain, buffer, 0);
    } else if (pvrQwsDisplay.usePresentBlit && drawable->numVisibleRects > 0) {
        PVR2DRECT pvrRects[PVRQWS_MAX_VISIBLE_RECTS];
        for (index = 0; index < drawable->numVisibleRects; ++index, ++rect) {
            pvrRects[index].left = rect->x;
            pvrRects[index].top = rect->y;
            pvrRects[index].right = rect->x + rect->width;
            pvrRects[index].bottom = rect->y + rect->height;
        }
        for (index = 0; index < drawable->numVisibleRects; index += 4) {
            int numClip = drawable->numVisibleRects - index;
            if (numClip > 4)    /* No more than 4 clip rects at a time */
                numClip = 4;
            PVR2DSetPresentBltProperties
                (pvrQwsDisplay.context,
                 PVR2D_PRESENT_PROPERTY_SRCSTRIDE |
                 PVR2D_PRESENT_PROPERTY_DSTSIZE |
                 PVR2D_PRESENT_PROPERTY_DSTPOS |
                 PVR2D_PRESENT_PROPERTY_CLIPRECTS,
                 drawable->strideBytes,
                 drawable->rect.width, drawable->rect.height,
                 drawable->rect.x, drawable->rect.y,
                 numClip, pvrRects + index, 0);
            PVR2DPresentBlt(pvrQwsDisplay.context, buffer, 0);
        }
        PVR2DQueryBlitsComplete(pvrQwsDisplay.context, buffer, 1);
    } else {
        /* TODO: use PVR2DBltClipped for faster transfers of clipped windows */
        PVR2DBLTINFO blit;
        for (index = 0; index < drawable->numVisibleRects; ++index, ++rect) {
            memset(&blit, 0, sizeof(blit));

            blit.CopyCode = PVR2DROPcopy;
            blit.BlitFlags = PVR2D_BLIT_DISABLE_ALL;

            blit.pSrcMemInfo = buffer;
            blit.SrcStride = drawable->strideBytes;
            blit.SrcX = rect->x - drawable->rect.x;
            blit.SrcY = rect->y - drawable->rect.y;
            blit.SizeX = rect->width;
            blit.SizeY = rect->height;
            blit.SrcFormat = drawable->pixelFormat;

            blit.pDstMemInfo = pvrQwsDisplay.screens[drawable->screen].frameBuffer;
            blit.DstStride = pvrQwsDisplay.screens[drawable->screen].screenStride;
            blit.DstX = rect->x;
            blit.DstY = rect->y;
            blit.DSizeX = rect->width;
            blit.DSizeY = rect->height;
            blit.DstFormat = pvrQwsDisplay.screens[drawable->screen].pixelFormat;

            PVR2DBlt(pvrQwsDisplay.context, &blit);
        }
    }

    /* Swap the buffers */
    if (!repaintOnly) {
        drawable->currentBackBuffer
            = (drawable->currentBackBuffer + 1) % PVRQWS_MAX_BACK_BUFFERS;
    }
    return 1;
}