SecBSD/xenocara
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
xenocara/driver/xf86-video-geode/src/gx_video.c

1578 lines
44 KiB
C
Raw Blame History

/* Copyright (c) 2003-2005 Advanced Micro Devices, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPDIs2IED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*
* Neither the name of the Advanced Micro Devices, Inc. nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
* */
/*
* File Contents: This file consists of main Xfree video supported routines.
*
* Project: Geode Xfree Frame buffer device driver.
* */
/*
* Fixes & Extensions to support Y800 greyscale modes
* Alan Hourihane <alanh@fairlite.demon.co.uk>
* code to allocate offscreen memory from EXA - is borrowed from Radeon
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdlib.h>
#include <string.h>
#include "xf86.h"
#include "xf86_OSproc.h"
#include "compiler.h"
#include "xf86PciInfo.h"
#include "xf86Pci.h"
#include "xf86fbman.h"
#include "regionstr.h"
#include "geode.h"
#include "xf86xv.h"
#include <X11/extensions/Xv.h>
#ifdef HAVE_XAA_H
#include "xaa.h"
#include "xaalocal.h"
#endif
#include "dixstruct.h"
#include "fourcc.h"
#include "geode_fourcc.h"
#define OFF_DELAY 200 /* milliseconds */
#define FREE_DELAY 60000
#define OFF_TIMER 0x01
#define FREE_TIMER 0x02
#define CLIENT_VIDEO_ON 0x04
#define TIMER_MASK (OFF_TIMER | FREE_TIMER)
#define XV_PROFILE 0
#define REINIT 1
#ifndef XvExtension
#error "It didn't work!"
void
GXInitVideo(ScreenPtr pScrn)
{
}
void
GXResetVideo(ScrnInfoPtr pScrni)
{
}
void
GXSetVideoPosition()
{
}
#else
#define DBUF 1
void GXResetVideo(ScrnInfoPtr pScrni);
static XF86VideoAdaptorPtr GXSetupImageVideo(ScreenPtr);
static void GXInitOffscreenImages(ScreenPtr);
static void GXStopVideo(ScrnInfoPtr, pointer, Bool);
static int GXSetPortAttribute(ScrnInfoPtr, Atom, INT32, pointer);
static int GXGetPortAttribute(ScrnInfoPtr, Atom, INT32 *, pointer);
static void GXQueryBestSize(ScrnInfoPtr, Bool,
short, short, short, short, unsigned int *,
unsigned int *, pointer);
static int GXPutImage(ScrnInfoPtr, short, short, short, short, short, short,
short, short, int, unsigned char *, short, short, Bool,
RegionPtr, pointer, DrawablePtr pDraw);
static void GXBlockHandler(BLOCKHANDLER_ARGS_DECL);
void GXSetVideoPosition(int x, int y, int width, int height,
short src_w, short src_h, short drw_w,
short drw_h, int id, int offset, ScrnInfoPtr pScrni);
extern void GXAccelSync(ScrnInfoPtr pScrni);
extern int DeltaX, DeltaY;
unsigned long graphics_lut[256];
static int lutflag = 0;
#define MAKE_ATOM(a) MakeAtom(a, sizeof(a) - 1, TRUE)
static Atom xvColorKey, xvColorKeyMode, xvFilter
#if DBUF
, xvDoubleBuffer
#endif
;
#define PALETTE_ADDRESS 0x038
#define PALETTE_DATA 0x040
#define DISPLAY_CONFIG 0x008
#define MISC 0x050
static void
get_gamma_ram(unsigned long *lut)
{
int i;
gfx_write_vid32(PALETTE_ADDRESS, 0);
for (i = 0; i < 256; i++)
lut[i] = gfx_read_vid32(PALETTE_DATA);
}
/*----------------------------------------------------------------------------
* GXInitVideo
*
* Description :This is the initialization routine.It creates a new video
* adapter and calls GXSetupImageVideo to initialize the adaptor
* by filling XF86VideoAdaptorREc.Then it lists the existing
* adaptors and adds the new one to it. Finally the list of
* XF86VideoAdaptorPtr pointers are passed to the
* xf86XVScreenInit().
*
* Parameters.
* pScrn :Screen handler pointer having screen information.
*
* Returns :none
*
* Comments :none
*----------------------------------------------------------------------------
*/
void
GXInitVideo(ScreenPtr pScrn)
{
GeodeRec *pGeode;
ScrnInfoPtr pScrni = xf86ScreenToScrn(pScrn);
pGeode = GEODEPTR(pScrni);
if (!pGeode->NoAccel) {
XF86VideoAdaptorPtr *adaptors, *newAdaptors = NULL;
XF86VideoAdaptorPtr newAdaptor = NULL;
int num_adaptors;
newAdaptor = GXSetupImageVideo(pScrn);
GXInitOffscreenImages(pScrn);
num_adaptors = xf86XVListGenericAdaptors(pScrni, &adaptors);
if (newAdaptor) {
if (!num_adaptors) {
num_adaptors = 1;
adaptors = &newAdaptor;
}
else {
newAdaptors = /* need to free this someplace */
malloc((num_adaptors + 1) * sizeof(XF86VideoAdaptorPtr *));
if (newAdaptors) {
memcpy(newAdaptors, adaptors, num_adaptors *
sizeof(XF86VideoAdaptorPtr));
newAdaptors[num_adaptors] = newAdaptor;
adaptors = newAdaptors;
num_adaptors++;
}
}
}
if (num_adaptors)
xf86XVScreenInit(pScrn, adaptors, num_adaptors);
if (newAdaptors)
free(newAdaptors);
}
}
/* client libraries expect an encoding */
static XF86VideoEncodingRec DummyEncoding[1] = {
{
0,
"XV_IMAGE",
1024, 1024,
{1, 1}
}
};
#define NUM_FORMATS 4
static XF86VideoFormatRec Formats[NUM_FORMATS] = {
{8, PseudoColor}, {15, TrueColor}, {16, TrueColor}, {24, TrueColor}
};
#if DBUF
#define NUM_ATTRIBUTES 4
#else
#define NUM_ATTRIBUTES 3
#endif
static XF86AttributeRec Attributes[NUM_ATTRIBUTES] = {
#if DBUF
{XvSettable | XvGettable, 0, 1, "XV_DOUBLE_BUFFER"},
#endif
{XvSettable | XvGettable, 0, (1 << 24) - 1, "XV_COLORKEY"},
{XvSettable | XvGettable, 0, 1, "XV_FILTER"},
{XvSettable | XvGettable, 0, 1, "XV_COLORKEYMODE"}
};
#define NUM_IMAGES 8
static XF86ImageRec Images[NUM_IMAGES] = {
XVIMAGE_UYVY,
XVIMAGE_YUY2,
XVIMAGE_Y2YU,
XVIMAGE_YVYU,
XVIMAGE_Y800,
XVIMAGE_I420,
XVIMAGE_YV12,
XVIMAGE_RGB565
};
typedef struct {
void *area;
int offset;
RegionRec clip;
CARD32 filter;
CARD32 colorKey;
CARD32 colorKeyMode;
CARD32 videoStatus;
Time offTime;
Time freeTime;
#if DBUF
Bool doubleBuffer;
int currentBuffer;
#endif
} GeodePortPrivRec, *GeodePortPrivPtr;
#define GET_PORT_PRIVATE(pScrni) \
(GeodePortPrivRec *)((GEODEPTR(pScrni))->adaptor->pPortPrivates[0].ptr)
/*----------------------------------------------------------------------------
* GXSetColorKey
*
* Description :This function reads the color key for the pallete and
* sets the video color key register.
*
* Parameters.
* ScreenInfoPtr
* pScrni :Screen pointer having screen information.
* pPriv :Video port private data
*
* Returns :none
*
* Comments :none
*
*----------------------------------------------------------------------------
*/
static INT32
GXSetColorkey(ScrnInfoPtr pScrni, GeodePortPrivRec * pPriv)
{
int red, green, blue;
unsigned long key;
switch (pScrni->depth) {
case 8:
GFX(get_display_palette_entry(pPriv->colorKey & 0xFF, &key));
red = ((key >> 16) & 0xFF);
green = ((key >> 8) & 0xFF);
blue = (key & 0xFF);
break;
case 16:
red = (pPriv->colorKey & pScrni->mask.red) >>
pScrni->offset.red << (8 - pScrni->weight.red);
green = (pPriv->colorKey & pScrni->mask.green) >>
pScrni->offset.green << (8 - pScrni->weight.green);
blue = (pPriv->colorKey & pScrni->mask.blue) >>
pScrni->offset.blue << (8 - pScrni->weight.blue);
break;
default:
/* for > 16 bpp we send in the mask in xf86SetWeight. This
* function is providing the offset by 1 more. So we take
* this as a special case and subtract 1 for > 16
*/
red = (pPriv->colorKey & pScrni->mask.red) >>
(pScrni->offset.red - 1) << (8 - pScrni->weight.red);
green = (pPriv->colorKey & pScrni->mask.green) >>
(pScrni->offset.green - 1) << (8 - pScrni->weight.green);
blue = (pPriv->colorKey & pScrni->mask.blue) >>
(pScrni->offset.blue - 1) << (8 - pScrni->weight.blue);
break;
}
GFX(set_video_color_key((blue | (green << 8) | (red << 16)), 0xFFFFFF,
(pPriv->colorKeyMode == 0)));
REGION_EMPTY(pScrni->pScreen, &pPriv->clip);
return 0;
}
/*----------------------------------------------------------------------------
* GXResetVideo
*
* Description : This function resets the video
*
* Parameters.
* pScrni :Screen pointer having screen information.
*
* Returns :None
*
* Comments :none
*
*----------------------------------------------------------------------------
*/
void
GXResetVideo(ScrnInfoPtr pScrni)
{
GeodeRec *pGeode = GEODEPTR(pScrni);
if (!pGeode->NoAccel) {
GeodePortPrivRec *pPriv = pGeode->adaptor->pPortPrivates[0].ptr;
GXAccelSync(pScrni);
GXSetColorkey(pScrni, pPriv);
GFX(set_video_filter(pPriv->filter, pPriv->filter));
}
}
/*----------------------------------------------------------------------------
* GXSetupImageVideo
*
* Description : This function allocates space for a Videoadaptor and
* initializes the XF86VideoAdaptorPtr record.
*
* Parameters.
* pScrn :Screen handler pointer having screen information.
*
* Returns :pointer to the initialized video adaptor record.
*
* Comments :none
*----------------------------------------------------------------------------
*/
static XF86VideoAdaptorPtr
GXSetupImageVideo(ScreenPtr pScrn)
{
ScrnInfoPtr pScrni = xf86ScreenToScrn(pScrn);
GeodeRec *pGeode = GEODEPTR(pScrni);
XF86VideoAdaptorPtr adapt;
GeodePortPrivRec *pPriv;
if (!(adapt = calloc(1, sizeof(XF86VideoAdaptorRec) +
sizeof(GeodePortPrivRec) + sizeof(DevUnion))))
return NULL;
adapt->type = XvWindowMask | XvInputMask | XvImageMask;
adapt->flags = VIDEO_OVERLAID_IMAGES | VIDEO_CLIP_TO_VIEWPORT;
adapt->name = "Advanced Micro Devices";
adapt->nEncodings = 1;
adapt->pEncodings = DummyEncoding;
adapt->nFormats = NUM_FORMATS;
adapt->pFormats = Formats;
adapt->nPorts = 1;
adapt->pPortPrivates = (DevUnion *) (&adapt[1]);
pPriv = (GeodePortPrivRec *) (&adapt->pPortPrivates[1]);
adapt->pPortPrivates[0].ptr = (pointer) (pPriv);
adapt->pAttributes = Attributes;
adapt->nImages = NUM_IMAGES;
adapt->nAttributes = NUM_ATTRIBUTES;
adapt->pImages = Images;
adapt->PutVideo = NULL;
adapt->PutStill = NULL;
adapt->GetVideo = NULL;
adapt->GetStill = NULL;
adapt->StopVideo = GXStopVideo;
adapt->SetPortAttribute = GXSetPortAttribute;
adapt->GetPortAttribute = GXGetPortAttribute;
adapt->QueryBestSize = GXQueryBestSize;
adapt->PutImage = GXPutImage;
adapt->QueryImageAttributes = GeodeQueryImageAttributes;
pPriv->filter = 0;
pPriv->colorKey = 0;
pPriv->colorKeyMode = 0;
pPriv->videoStatus = 0;
#if DBUF
pPriv->doubleBuffer = TRUE;
pPriv->currentBuffer = 0; /* init to first buffer */
#endif
/* gotta uninit this someplace */
#if defined(REGION_NULL)
REGION_NULL(pScrn, &pPriv->clip);
#else
REGION_INIT(pScrn, &pPriv->clip, NullBox, 0);
#endif
pGeode->adaptor = adapt;
pGeode->BlockHandler = pScrn->BlockHandler;
pScrn->BlockHandler = GXBlockHandler;
xvColorKey = MAKE_ATOM("XV_COLORKEY");
xvColorKeyMode = MAKE_ATOM("XV_COLORKEYMODE");
xvFilter = MAKE_ATOM("XV_FILTER");
#if DBUF
xvDoubleBuffer = MAKE_ATOM("XV_DOUBLE_BUFFER");
#endif
GXResetVideo(pScrni);
return adapt;
}
/*----------------------------------------------------------------------------
* GXStopVideo
*
* Description :This function is used to stop input and output video
*
* Parameters.
* pScrni :Screen handler pointer having screen information.
* data :Pointer to the video port's private data
* exit :Flag indicating whether the offscreen areas used for
* video to be deallocated or not.
*
* Returns :none
*
* Comments :none
*----------------------------------------------------------------------------
*/
static void
GXStopVideo(ScrnInfoPtr pScrni, pointer data, Bool exit)
{
GeodePortPrivRec *pPriv = (GeodePortPrivRec *) data;
GeodeRec *pGeode = GEODEPTR(pScrni);
REGION_EMPTY(pScrni->pScreen, &pPriv->clip);
GXAccelSync(pScrni);
if (exit) {
if (pPriv->videoStatus & CLIENT_VIDEO_ON) {
GFX(set_video_enable(0));
/* If we have saved graphics LUT data - restore it */
/* Otherwise, turn bypass on */
if (lutflag)
GFX(set_graphics_palette(graphics_lut));
else
GFX(set_video_palette_bypass(1));
lutflag = 0;
}
if (pPriv->area) {
#ifdef XF86EXA
if (pGeode->useEXA)
exaOffscreenFree(pScrni->pScreen, pPriv->area);
#endif
if (!pGeode->useEXA)
xf86FreeOffscreenArea(pPriv->area);
pPriv->area = NULL;
}
pPriv->videoStatus = 0;
pGeode->OverlayON = FALSE;
}
else {
if (pPriv->videoStatus & CLIENT_VIDEO_ON) {
pPriv->videoStatus |= OFF_TIMER;
pPriv->offTime = currentTime.milliseconds + OFF_DELAY;
}
}
}
/*----------------------------------------------------------------------------
* GXSetPortAttribute
*
* Description :This function is used to set the attributes of a port
* like colorkeymode, double buffer support and filter.
*
* Parameters.
* pScrni :Screen handler pointer having screen information.
* data :Pointer to the video port's private data
* attribute :The port attribute to be set
* value :Value of the attribute to be set.
*
* Returns :Sucess if the attribute is supported, else BadMatch
*
* Comments :none
*----------------------------------------------------------------------------
*/
static int
GXSetPortAttribute(ScrnInfoPtr pScrni,
Atom attribute, INT32 value, pointer data)
{
GeodePortPrivRec *pPriv = (GeodePortPrivRec *) data;
GXAccelSync(pScrni);
if (attribute == xvColorKey) {
pPriv->colorKey = value;
GXSetColorkey(pScrni, pPriv);
}
#if DBUF
else if (attribute == xvDoubleBuffer) {
if ((value < 0) || (value > 1))
return BadValue;
pPriv->doubleBuffer = value;
}
#endif
else if (attribute == xvColorKeyMode) {
pPriv->colorKeyMode = value;
GXSetColorkey(pScrni, pPriv);
}
else if (attribute == xvFilter) {
if ((value < 0) || (value > 1))
return BadValue;
pPriv->filter = value;
}
else
return BadMatch;
return Success;
}
/*----------------------------------------------------------------------------
* GXGetPortAttribute
*
* Description :This function is used to get the attributes of a port
* like hue, saturation,brightness or contrast.
*
* Parameters.
* pScrni :Screen handler pointer having screen information.
* data :Pointer to the video port's private data
* attribute :The port attribute to be read
* value :Pointer to the value of the attribute to be read.
*
* Returns :Sucess if the attribute is supported, else BadMatch
*
* Comments :none
*----------------------------------------------------------------------------
*/
static int
GXGetPortAttribute(ScrnInfoPtr pScrni,
Atom attribute, INT32 *value, pointer data)
{
GeodePortPrivRec *pPriv = (GeodePortPrivRec *) data;
if (attribute == xvColorKey) {
*value = pPriv->colorKey;
}
#if DBUF
else if (attribute == xvDoubleBuffer) {
*value = (pPriv->doubleBuffer) ? 1 : 0;
}
#endif
else if (attribute == xvColorKeyMode) {
*value = pPriv->colorKeyMode;
}
else if (attribute == xvFilter) {
*value = pPriv->filter;
}
else
return BadMatch;
return Success;
}
/*----------------------------------------------------------------------------
* GXQueryBestSize
*
* Description :This function provides a way to query what the
* destination dimensions would end up being if they were to
* request that an area vid_w by vid_h from the video stream
* be scaled to rectangle of drw_w by drw_h on the screen.
*
* Parameters.
* pScrni :Screen handler pointer having screen information.
* data :Pointer to the video port's private data
* vid_w,vid_h :Width and height of the video data.
* drw_w,drw_h :Width and height of the scaled rectangle.
* p_w,p_h :Width and height of the destination rectangle.
*
* Returns :None
*
* Comments :None
*----------------------------------------------------------------------------
*/
static void
GXQueryBestSize(ScrnInfoPtr pScrni,
Bool motion,
short vid_w, short vid_h,
short drw_w, short drw_h,
unsigned int *p_w, unsigned int *p_h, pointer data)
{
*p_w = drw_w;
*p_h = drw_h;
if (*p_w > 16384)
*p_w = 16384;
}
/*----------------------------------------------------------------------------
* GXCopyData420
*
* Description : Copies data from src to destination
*
* Parameters.
* src : pointer to the source data
* dst : pointer to destination data
* srcPitch : pitch of the srcdata
* dstPitch : pitch of the destination data
* h & w : height and width of source data
*
* Returns :None
*
* Comments :None
*----------------------------------------------------------------------------
*/
static void
GXCopyData420(unsigned char *src, unsigned char *dst,
int srcPitch, int dstPitch, int h, int w)
{
while (h--) {
memcpy(dst, src, w);
src += srcPitch;
dst += dstPitch;
}
}
/*----------------------------------------------------------------------------
* GXCopyData422
*
* Description : Copies data from src to destination
*
* Parameters.
* src : pointer to the source data
* dst : pointer to destination data
* srcPitch : pitch of the srcdata
* dstPitch : pitch of the destination data
* h & w : height and width of source data
*
* Returns :None
*
* Comments :None
*----------------------------------------------------------------------------
*/
static void
GXCopyData422(unsigned char *src, unsigned char *dst,
int srcPitch, int dstPitch, int h, int w)
{
w <<= 1;
while (h--) {
memcpy(dst, src, w);
src += srcPitch;
dst += dstPitch;
}
}
#ifdef XF86EXA
static void
GXVideoSave(ScreenPtr pScreen, ExaOffscreenArea * area)
{
ScrnInfoPtr pScrni = xf86ScreenToScrn(pScreen);
GeodePortPrivRec *pPriv = GET_PORT_PRIVATE(pScrni);
if (area == pPriv->area)
pPriv->area = NULL;
}
#endif
static int
GXAllocateMemory(ScrnInfoPtr pScrni, void **memp, int numlines)
{
ScreenPtr pScrn = xf86ScrnToScreen(pScrni);
GeodeRec *pGeode = GEODEPTR(pScrni);
//long displayWidth = pGeode->Pitch / ((pScrni->bitsPerPixel + 7) / 8);
int size = numlines * pGeode->displayWidth;
#if XF86EXA
if (pGeode->useEXA) {
ExaOffscreenArea *area = *memp;
if (area != NULL) {
if (area->size >= size)
return area->offset;
exaOffscreenFree(pScrni->pScreen, area);
}
area = exaOffscreenAlloc(pScrni->pScreen, size, 16,
TRUE, GXVideoSave, NULL);
*memp = area;
return area == NULL ? 0 : area->offset;
}
#endif
if (!pGeode->useEXA) {
FBAreaPtr area = *memp;
FBAreaPtr new_area;
if (area) {
if ((area->box.y2 - area->box.y1) >= numlines)
return (area->box.y1 * pGeode->Pitch);
if (xf86ResizeOffscreenArea(area, pGeode->displayWidth, numlines))
return (area->box.y1 * pGeode->Pitch);
xf86FreeOffscreenArea(area);
}
new_area = xf86AllocateOffscreenArea(pScrn, pGeode->displayWidth,
numlines, 0, NULL, NULL, NULL);
if (!new_area) {
int max_w, max_h;
xf86QueryLargestOffscreenArea(pScrn, &max_w, &max_h, 0,
FAVOR_WIDTH_THEN_AREA,
PRIORITY_EXTREME);
if ((max_w < pGeode->displayWidth) || (max_h < numlines)) {
xf86DrvMsg(pScrni->scrnIndex, X_ERROR,
"No room - how sad %x, %x, %x, %x\n", max_w,
pGeode->displayWidth, max_h, numlines);
return 0;
}
xf86PurgeUnlockedOffscreenAreas(pScrn);
new_area = xf86AllocateOffscreenArea(pScrn, pGeode->displayWidth,
numlines, 0, NULL, NULL, NULL);
}
return (new_area->box.y1 * pGeode->Pitch);
}
return 0;
}
static BoxRec dstBox;
static int srcPitch = 0, srcPitch2 = 0, dstPitch = 0, dstPitch2 = 0;
static INT32 Bx1, Bx2, By1, By2;
static int top, left, npixels, nlines;
static int offset, s1offset = 0, s2offset = 0, s3offset = 0;
static unsigned char *dst_start;
static int d2offset = 0, d3offset = 0;
#if 0
static Bool
RegionsIntersect(BoxPtr pRcl1, BoxPtr pRcl2, BoxPtr pRclResult)
{
pRclResult->x1 = max(pRcl1->x1, pRcl2->x1);
pRclResult->x2 = min(pRcl1->x2, pRcl2->x2);
if (pRclResult->x1 <= pRclResult->x2) {
pRclResult->y1 = max(pRcl1->y1, pRcl2->y1);
pRclResult->y2 = min(pRcl1->y2, pRcl2->y2);
if (pRclResult->y1 <= pRclResult->y2) {
return (TRUE);
}
}
return (FALSE);
}
#endif
void
GXSetVideoPosition(int x, int y, int width, int height,
short src_w, short src_h, short drw_w, short drw_h,
int id, int offset, ScrnInfoPtr pScrni)
{
GeodeRec *pGeode = GEODEPTR(pScrni);
long ystart, xend, yend;
unsigned long lines = 0;
unsigned long y_extra, uv_extra = 0;
unsigned long startAddress;
#if 0
BoxRec ovly, display, result;
#endif
xend = x + drw_w;
yend = y + drw_h;
/* Take care of panning when panel is present */
startAddress = gfx_get_display_offset();
DeltaY = startAddress / pGeode->Pitch;
DeltaX = startAddress & (pGeode->Pitch - 1);
DeltaX /= (pScrni->bitsPerPixel >> 3);
#if 0
/* Thhis code is pretty dang broken - comment it out for now */
if (pGeode->Panel) {
ovly.x1 = x;
ovly.x2 = x + pGeode->video_dstw;
ovly.y1 = y;
ovly.y2 = y + pGeode->video_dsth;
display.x1 = DeltaX;
display.x2 = DeltaX + pGeode->FPBX;
display.y1 = DeltaY;
display.y2 = DeltaY + pGeode->FPBY;
x = xend = 0;
if (RegionsIntersect(&display, &ovly, &result)) {
x = ovly.x1 - DeltaX;
xend = ovly.x2 - DeltaX;
y = ovly.y1 - DeltaY;
yend = ovly.y2 - DeltaY;
}
}
#endif
/* TOP CLIPPING */
if (y < 0) {
if (src_h < drw_h)
lines = (-y) * src_h / drw_h;
else
lines = (-y);
ystart = 0;
drw_h += y;
y_extra = lines * dstPitch;
uv_extra = (lines >> 1) * (dstPitch2);
}
else {
ystart = y;
lines = 0;
y_extra = 0;
}
GFX(set_video_window(x, ystart, xend - x, yend - ystart));
if ((id == FOURCC_Y800) || (id == FOURCC_I420) || (id == FOURCC_YV12)) {
GFX(set_video_yuv_offsets(offset + y_extra,
offset + d3offset + uv_extra,
offset + d2offset + uv_extra));
}
else {
GFX(set_video_offset(offset + y_extra));
}
}
/*----------------------------------------------------------------------------
* GXDisplayVideo
*
* Description :This function sets up the video registers for playing video
* It sets up the video format,width, height & position of the
* video window ,video offsets( y,u,v) and video pitches(y,u,v)
*
* Parameters
*
* Returns :None
*
* Comments :None
*----------------------------------------------------------------------------
*/
static void
GXDisplayVideo(ScrnInfoPtr pScrni,
int id,
int offset,
short width, short height,
int pitch,
int x1, int y1, int x2, int y2,
BoxPtr dstBox, short src_w, short src_h, short drw_w,
short drw_h)
{
GeodeRec *pGeode = GEODEPTR(pScrni);
unsigned long dcfg, misc;
GXAccelSync(pScrni);
/* If the gamma LUT is already loaded with graphics data, then save it
* off
*/
if (id != FOURCC_RGB565) {
dcfg = gfx_read_vid32(DISPLAY_CONFIG);
misc = gfx_read_vid32(MISC);
lutflag = (!(misc & 1) && (dcfg & (1 << 21)));
if (lutflag)
get_gamma_ram(graphics_lut);
/* Set the video gamma ram */
GFX(set_video_palette(NULL));
}
GFX(set_video_enable(1));
switch (id) {
case FOURCC_UYVY: /* UYVY */
GFX(set_video_format(VIDEO_FORMAT_UYVY));
GFX(set_video_size(width, height));
break;
case FOURCC_Y800: /* Y800 - greyscale - we munge it! */
case FOURCC_YV12: /* YV12 */
case FOURCC_I420: /* I420 */
GFX(set_video_format(VIDEO_FORMAT_Y0Y1Y2Y3));
GFX(set_video_size(width, height));
GFX(set_video_yuv_pitch(dstPitch, dstPitch2));
break;
case FOURCC_YUY2: /* YUY2 */
GFX(set_video_format(VIDEO_FORMAT_YUYV));
GFX(set_video_size(width, height));
break;
case FOURCC_Y2YU: /* Y2YU */
GFX(set_video_format(VIDEO_FORMAT_Y2YU));
GFX(set_video_size(width, height));
break;
case FOURCC_YVYU: /* YVYU */
GFX(set_video_format(VIDEO_FORMAT_YVYU));
GFX(set_video_size(width, height));
break;
case FOURCC_RGB565:
GFX(set_video_format(VIDEO_FORMAT_RGB));
GFX(set_video_size(width, height));
break;
}
if (pGeode->Panel) {
pGeode->video_x = dstBox->x1;
pGeode->video_y = dstBox->y1;
pGeode->video_w = width;
pGeode->video_h = height;
pGeode->video_srcw = src_w;
pGeode->video_srch = src_h;
pGeode->video_dstw = drw_w;
pGeode->video_dsth = drw_h;
pGeode->video_offset = offset;
pGeode->video_id = id;
pGeode->video_scrnptr = pScrni;
}
if ((drw_w >= src_w) && (drw_h >= src_h))
GFX(set_video_scale(width, height, drw_w, drw_h));
else if (drw_w < src_w)
GFX(set_video_scale(drw_w, height, drw_w, drw_h));
else if (drw_h < src_h)
GFX(set_video_scale(width, drw_h, drw_w, drw_h));
GXSetVideoPosition(dstBox->x1, dstBox->y1, width, height, src_w,
src_h, drw_w, drw_h, id, offset, pScrni);
}
/* Used by LX as well */
Bool
RegionsEqual(RegionPtr A, RegionPtr B)
{
int *dataA, *dataB;
int num;
num = REGION_NUM_RECTS(A);
if (num != REGION_NUM_RECTS(B)) {
return FALSE;
}
if ((A->extents.x1 != B->extents.x1) ||
(A->extents.x2 != B->extents.x2) ||
(A->extents.y1 != B->extents.y1) || (A->extents.y2 != B->extents.y2))
return FALSE;
dataA = (int *) REGION_RECTS(A);
dataB = (int *) REGION_RECTS(B);
while (num--) {
if ((dataA[0] != dataB[0]) || (dataA[1] != dataB[1]))
return FALSE;
dataA += 2;
dataB += 2;
}
return TRUE;
}
/*----------------------------------------------------------------------------
* GXPutImage :This function writes a single frame of video into a
* drawable. The position and size of the source rectangle is
* specified by src_x,src_y, src_w and src_h. This data is
* stored in a system memory buffer at buf. The position and
* size of the destination rectangle is specified by drw_x,
* drw_y,drw_w,drw_h.The data is in the format indicated by the
* image descriptor and represents a source of size width by
* height. If sync is TRUE the driver should not return from
* this function until it is through reading the data from buf.
* Returning when sync is TRUE indicates that it is safe for the
* data at buf to be replaced,freed, or modified.
*
* Parameters.
*
* Returns :None
*
* Comments :None
*----------------------------------------------------------------------------
*/
static int
GXPutImage(ScrnInfoPtr pScrni,
short src_x, short src_y,
short drw_x, short drw_y,
short src_w, short src_h,
short drw_w, short drw_h,
int id, unsigned char *buf,
short width, short height, Bool sync, RegionPtr clipBoxes,
pointer data, DrawablePtr pDraw)
{
GeodePortPrivRec *pPriv = (GeodePortPrivRec *) data;
GeodeRec *pGeode = GEODEPTR(pScrni);
int new_h;
#if REINIT
BOOL ReInitVideo = FALSE;
static BOOL DoReinitAgain = 0;
#endif
#if XV_PROFILE
long oldtime, newtime;
UpdateCurrentTime();
oldtime = currentTime.milliseconds;
#endif
#if REINIT
/* update cliplist */
if (!RegionsEqual(&pPriv->clip, clipBoxes)) {
ReInitVideo = TRUE;
}
if (DoReinitAgain)
ReInitVideo = TRUE;
if (ReInitVideo) {
DEBUGMSG(1, (0, X_NONE, "Regional Not Equal - Init\n"));
#endif
DoReinitAgain = ~DoReinitAgain;
if (drw_w > 16384)
drw_w = 16384;
/* Clip */
Bx1 = src_x;
Bx2 = src_x + src_w;
By1 = src_y;
By2 = src_y + src_h;
if ((Bx1 >= Bx2) || (By1 >= By2))
return Success;
dstBox.x1 = drw_x;
dstBox.x2 = drw_x + drw_w;
dstBox.y1 = drw_y;
dstBox.y2 = drw_y + drw_h;
dstBox.x1 -= pScrni->frameX0;
dstBox.x2 -= pScrni->frameX0;
dstBox.y1 -= pScrni->frameY0;
dstBox.y2 -= pScrni->frameY0;
switch (id) {
case FOURCC_YV12:
case FOURCC_I420:
srcPitch = (width + 3) & ~3; /* of luma */
dstPitch = (width + 31) & ~31;
s2offset = srcPitch * height;
d2offset = dstPitch * height;
srcPitch2 = ((width >> 1) + 3) & ~3;
dstPitch2 = ((width >> 1) + 15) & ~15;
s3offset = (srcPitch2 * (height >> 1)) + s2offset;
d3offset = (dstPitch2 * (height >> 1)) + d2offset;
new_h = dstPitch * height; /* Y */
new_h += (dstPitch2 * height); /* U+V */
new_h += pGeode->Pitch - 1;
new_h /= pGeode->Pitch;
break;
case FOURCC_UYVY:
case FOURCC_YUY2:
case FOURCC_Y800:
case FOURCC_RGB565:
default:
dstPitch = ((width << 1) + 3) & ~3;
srcPitch = (width << 1);
new_h = ((dstPitch * height) + pGeode->Pitch - 1) / pGeode->Pitch;
break;
}
#if DBUF
if (pPriv->doubleBuffer)
new_h <<= 1;
#endif
if (!(pPriv->offset = GXAllocateMemory(pScrni, &pPriv->area, new_h))) {
xf86DrvMsg(pScrni->scrnIndex, X_ERROR,
"Could not allocate area of size %d\n", new_h);
return BadAlloc;
}
/* copy data */
top = By1;
left = Bx1 & ~1;
npixels = ((Bx2 + 1) & ~1) - left;
switch (id) {
case FOURCC_YV12:
case FOURCC_I420:
{
int tmp;
top &= ~1;
offset = pPriv->offset + (top * dstPitch);
#if DBUF
if (pPriv->doubleBuffer && pPriv->currentBuffer)
offset += (new_h >> 1) * pGeode->Pitch;
#endif
dst_start = pGeode->FBBase + offset + left;
tmp = ((top >> 1) * srcPitch2) + (left >> 1);
s2offset += tmp;
s3offset += tmp;
if (id == FOURCC_I420) {
tmp = s2offset;
s2offset = s3offset;
s3offset = tmp;
}
nlines = ((By2 + 1) & ~1) - top;
}
break;
case FOURCC_UYVY:
case FOURCC_YUY2:
case FOURCC_Y800:
case FOURCC_RGB565:
default:
left <<= 1;
buf += (top * srcPitch) + left;
nlines = By2 - top;
offset = (pPriv->offset) + (top * dstPitch);
#if DBUF
if (pPriv->doubleBuffer && pPriv->currentBuffer)
offset += (new_h >> 1) * pGeode->Pitch;
#endif
dst_start = pGeode->FBBase + offset + left;
break;
}
s1offset = (top * srcPitch) + left;
#if REINIT
/* update cliplist */
REGION_COPY(pScrni->pScreen, &pPriv->clip, clipBoxes);
if (pPriv->colorKeyMode == 0) {
xf86XVFillKeyHelper(pScrni->pScreen, pPriv->colorKey, clipBoxes);
}
GXDisplayVideo(pScrni, id, offset, width, height, dstPitch,
Bx1, By1, Bx2, By2, &dstBox, src_w, src_h, drw_w, drw_h);
}
#endif
switch (id) {
case FOURCC_Y800:
/* This is shared between LX and GX, so it lives in amd_common.c */
GeodeCopyGreyscale(buf, dst_start, srcPitch, dstPitch, nlines, npixels);
break;
case FOURCC_YV12:
case FOURCC_I420:
GXCopyData420(buf + s1offset, dst_start, srcPitch, dstPitch, nlines,
npixels);
GXCopyData420(buf + s2offset, dst_start + d2offset, srcPitch2,
dstPitch2, nlines >> 1, npixels >> 1);
GXCopyData420(buf + s3offset, dst_start + d3offset, srcPitch2,
dstPitch2, nlines >> 1, npixels >> 1);
break;
case FOURCC_UYVY:
case FOURCC_YUY2:
case FOURCC_RGB565:
default:
GXCopyData422(buf, dst_start, srcPitch, dstPitch, nlines, npixels);
break;
}
#if !REINIT
/* update cliplist */
REGION_COPY(pScrni->pScreen, &pPriv->clip, clipBoxes);
if (pPriv->colorKeyMode == 0) {
/* draw these */
XAAFillSolidRects(pScrni, pPriv->colorKey, GXcopy, ~0,
REGION_NUM_RECTS(clipBoxes), REGION_RECTS(clipBoxes));
}
GXDisplayVideo(pScrni, id, offset, width, height, dstPitch,
Bx1, By1, Bx2, By2, &dstBox, src_w, src_h, drw_w, drw_h);
#endif
#if XV_PROFILE
UpdateCurrentTime();
newtime = currentTime.milliseconds;
DEBUGMSG(1, (0, X_NONE, "PI %d\n", newtime - oldtime));
#endif
#if DBUF
pPriv->currentBuffer ^= 1;
#endif
pPriv->videoStatus = CLIENT_VIDEO_ON;
pGeode->OverlayON = TRUE;
return Success;
}
/*----------------------------------------------------------------------------
* GXQueryImageAttributes
*
* Description :This function is called to let the driver specify how data
* for a particular image of size width by height should be
* stored.
*
* Parameters.
* pScrni :Screen handler pointer having screen information.
* id :Id for the video format
* width :width of the image (can be modified by the driver)
* height :height of the image (can be modified by the driver)
* Returns : Size of the memory required for storing this image
*
* Comments :None
*
*----------------------------------------------------------------------------
*/
int
GeodeQueryImageAttributes(ScrnInfoPtr pScrni,
int id, unsigned short *w, unsigned short *h,
int *pitches, int *offsets)
{
int size;
int tmp;
DEBUGMSG(0, (0, X_NONE, "QueryImageAttributes %X\n", id));
if (*w > 1024)
*w = 1024;
if (*h > 1024)
*h = 1024;
*w = (*w + 1) & ~1;
if (offsets)
offsets[0] = 0;
switch (id) {
case FOURCC_YV12:
case FOURCC_I420:
*h = (*h + 1) & ~1;
size = (*w + 3) & ~3;
if (pitches)
pitches[0] = size;
size *= *h;
if (offsets)
offsets[1] = size;
tmp = ((*w >> 1) + 3) & ~3;
if (pitches)
pitches[1] = pitches[2] = tmp;
tmp *= (*h >> 1);
size += tmp;
if (offsets)
offsets[2] = size;
size += tmp;
break;
case FOURCC_UYVY:
case FOURCC_YUY2:
case FOURCC_Y800:
default:
size = *w << 1;
if (pitches)
pitches[0] = size;
size *= *h;
break;
}
return size;
}
static void
GXBlockHandler(BLOCKHANDLER_ARGS_DECL)
{
SCREEN_PTR(arg);
ScrnInfoPtr pScrni = xf86ScreenToScrn(pScrn);
GeodeRec *pGeode = GEODEPTR(pScrni);
GeodePortPrivRec *pPriv = GET_PORT_PRIVATE(pScrni);
pScrn->BlockHandler = pGeode->BlockHandler;
(*pScrn->BlockHandler) (BLOCKHANDLER_ARGS);
pScrn->BlockHandler = GXBlockHandler;
if (pPriv->videoStatus & TIMER_MASK) {
GXAccelSync(pScrni);
UpdateCurrentTime();
if (pPriv->videoStatus & OFF_TIMER) {
if (pPriv->offTime < currentTime.milliseconds) {
GFX(set_video_enable(0));
/* If we have saved graphics LUT data - restore it */
/* Otherwise, turn bypass on */
if (lutflag)
GFX(set_graphics_palette(graphics_lut));
else
GFX(set_video_palette_bypass(1));
lutflag = 0;
pPriv->videoStatus = FREE_TIMER;
pPriv->freeTime = currentTime.milliseconds + FREE_DELAY;
}
}
else { /* FREE_TIMER */
if (pPriv->freeTime < currentTime.milliseconds) {
if (pPriv->area) {
#ifdef XF86EXA
if (pGeode->useEXA)
exaOffscreenFree(pScrn, pPriv->area);
#endif
if (!pGeode->useEXA)
xf86FreeOffscreenArea(pPriv->area);
pPriv->area = NULL;
}
pPriv->videoStatus = 0;
}
}
}
}
/****************** Offscreen stuff ***************/
typedef struct {
void *area;
int offset;
Bool isOn;
} OffscreenPrivRec, *OffscreenPrivPtr;
/*----------------------------------------------------------------------------
* GXAllocateSurface
*
* Description :This function allocates an area of w by h in the offscreen
*
* Parameters.
* pScrni :Screen handler pointer having screen information.
*
* Returns :None
*
* Comments :None
*----------------------------------------------------------------------------
*/
static int
GXAllocateSurface(ScrnInfoPtr pScrni,
int id, unsigned short w, unsigned short h,
XF86SurfacePtr surface)
{
void *area = NULL;
int pitch, fbpitch, numlines;
OffscreenPrivRec *pPriv;
if ((w > 1024) || (h > 1024))
return BadAlloc;
w = (w + 1) & ~1;
pitch = ((w << 1) + 15) & ~15;
fbpitch = pScrni->bitsPerPixel * pScrni->displayWidth >> 3;
numlines = ((pitch * h) + fbpitch - 1) / fbpitch;
if (!(offset = GXAllocateMemory(pScrni, &area, numlines)))
return BadAlloc;
surface->width = w;
surface->height = h;
if (!(surface->pitches = malloc(sizeof(int))))
return BadAlloc;
if (!(surface->offsets = malloc(sizeof(int)))) {
free(surface->pitches);
return BadAlloc;
}
if (!(pPriv = malloc(sizeof(OffscreenPrivRec)))) {
free(surface->pitches);
free(surface->offsets);
return BadAlloc;
}
pPriv->area = area;
pPriv->offset = offset;
pPriv->isOn = FALSE;
surface->pScrn = pScrni;
surface->id = id;
surface->pitches[0] = pitch;
surface->offsets[0] = offset;
surface->devPrivate.ptr = (pointer) pPriv;
return Success;
}
static int
GXStopSurface(XF86SurfacePtr surface)
{
OffscreenPrivRec *pPriv = (OffscreenPrivRec *) surface->devPrivate.ptr;
if (pPriv->isOn) {
pPriv->isOn = FALSE;
}
return Success;
}
static int
GXFreeSurface(XF86SurfacePtr surface)
{
OffscreenPrivRec *pPriv = (OffscreenPrivRec *) surface->devPrivate.ptr;
if (pPriv->isOn)
GXStopSurface(surface);
xf86FreeOffscreenArea(pPriv->area);
free(surface->pitches);
free(surface->offsets);
free(surface->devPrivate.ptr);
return Success;
}
static int
GXGetSurfaceAttribute(ScrnInfoPtr pScrni, Atom attribute, INT32 *value)
{
return GXGetPortAttribute(pScrni, attribute, value,
(pointer) (GET_PORT_PRIVATE(pScrni)));
}
static int
GXSetSurfaceAttribute(ScrnInfoPtr pScrni, Atom attribute, INT32 value)
{
return GXSetPortAttribute(pScrni, attribute, value,
(pointer) (GET_PORT_PRIVATE(pScrni)));
}
static int
GXDisplaySurface(XF86SurfacePtr surface,
short src_x, short src_y,
short drw_x, short drw_y,
short src_w, short src_h, short drw_w, short drw_h,
RegionPtr clipBoxes)
{
OffscreenPrivRec *pPriv = (OffscreenPrivRec *) surface->devPrivate.ptr;
ScrnInfoPtr pScrni = surface->pScrn;
GeodePortPrivRec *portPriv = GET_PORT_PRIVATE(pScrni);
INT32 x1, y1, x2, y2;
BoxRec dstBox;
DEBUGMSG(0, (0, X_NONE, "DisplaySuface\n"));
x1 = src_x;
x2 = src_x + src_w;
y1 = src_y;
y2 = src_y + src_h;
dstBox.x1 = drw_x;
dstBox.x2 = drw_x + drw_w;
dstBox.y1 = drw_y;
dstBox.y2 = drw_y + drw_h;
if ((x1 >= x2) || (y1 >= y2))
return Success;
dstBox.x1 -= pScrni->frameX0;
dstBox.x2 -= pScrni->frameX0;
dstBox.y1 -= pScrni->frameY0;
dstBox.y2 -= pScrni->frameY0;
xf86XVFillKeyHelper(pScrni->pScreen, portPriv->colorKey, clipBoxes);
GXDisplayVideo(pScrni, surface->id, surface->offsets[0],
surface->width, surface->height, surface->pitches[0],
x1, y1, x2, y2, &dstBox, src_w, src_h, drw_w, drw_h);
pPriv->isOn = TRUE;
if (portPriv->videoStatus & CLIENT_VIDEO_ON) {
REGION_EMPTY(pScrni->pScreen, &portPriv->clip);
UpdateCurrentTime();
portPriv->videoStatus = FREE_TIMER;
portPriv->freeTime = currentTime.milliseconds + FREE_DELAY;
}
return Success;
}
/*----------------------------------------------------------------------------
* GXInitOffscreenImages
*
* Description :This function sets up the offscreen memory management. It
* fills in the XF86OffscreenImagePtr structure with functions to
* handle offscreen memory operations.
*
* Parameters.
* pScrn :Screen handler pointer having screen information.
*
* Returns : None
*
* Comments :None
*----------------------------------------------------------------------------
*/
static void
GXInitOffscreenImages(ScreenPtr pScrn)
{
XF86OffscreenImagePtr offscreenImages;
/* need to free this someplace */
if (!(offscreenImages = malloc(sizeof(XF86OffscreenImageRec))))
return;
offscreenImages[0].image = &Images[0];
offscreenImages[0].flags = VIDEO_OVERLAID_IMAGES | VIDEO_CLIP_TO_VIEWPORT;
offscreenImages[0].alloc_surface = GXAllocateSurface;
offscreenImages[0].free_surface = GXFreeSurface;
offscreenImages[0].display = GXDisplaySurface;
offscreenImages[0].stop = GXStopSurface;
offscreenImages[0].setAttribute = GXSetSurfaceAttribute;
offscreenImages[0].getAttribute = GXGetSurfaceAttribute;
offscreenImages[0].max_width = 1024;
offscreenImages[0].max_height = 1024;
offscreenImages[0].num_attributes = NUM_ATTRIBUTES;
offscreenImages[0].attributes = Attributes;
xf86XVRegisterOffscreenImages(pScrn, offscreenImages, 1);
}
#endif /* !XvExtension */
Reference in a new issue View git blame Copy permalink