neomagic.diff

linux TV 源码

+    diff = extents->y1 - dst->y1;
+    if (diff > 0){
+	dst->y1 = extents->y1;
+	*y1 += diff * vscale;
+    }
+
+    diff = dst->x2 - extents->x2;
+    if (diff > 0){
+	dst->x2 = extents->x2;
+	*x2 -= diff * hscale;
+    }
+
+    diff = dst->y2 - extents->y2;
+    if (diff > 0){
+	dst->y2 = extents->y2;
+	*y2 -= diff * vscale;
+    }
+
+    if (*x1 < 0){
+	diff = (-*x1 + hscale - 1) / hscale;
+	dst->x1 += diff;
+	*x1 += diff * hscale;
+    }
+
+    if (*y1 < 0){
+	diff = (-*y1 + vscale - 1) / vscale;
+	dst->y1 += diff;
+	*y1 += diff * vscale;
+    }
+
+    delta = *x2 - (width << 16);
+    if (delta > 0){
+	diff = (delta + hscale - 1) / hscale;
+	dst->x2 -= diff;
+	*x2 -= diff * hscale;
+    }
+
+    delta = *y2 - (height << 16);
+    if (delta > 0){
+	diff = (delta + vscale - 1) / vscale;
+	dst->y2 -= diff;
+	*y2 -= diff * vscale;
+    }
+
+    if ((*x1 >= *x2) || (*y1 >= *y2)){
+	return (FALSE);
+    }
+
+    if ((dst->x1 != extents->x1) || (dst->y1 != extents->y1)
+	|| (dst->x2 != extents->x2) || (dst->y2 != extents->y2)){
+	RegionRec clipReg;
+	REGION_INIT(pScrn, &clipReg, dst, 1);
+	REGION_INTERSECT(pScrn, reg, reg, &clipReg);
+	REGION_UNINIT(pScrn, &clipReg);
+    }
+    return (TRUE);
+}
+
+static void
+NEODisplayVideo(ScrnInfoPtr pScrn, 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)
+{
+    NEOPtr nPtr = NEOPTR(pScrn);
+    int hstretch, vstretch, fmt;
+
+#ifdef DEBUG
+    xf86DrvMsg(pScrn->scrnIndex,X_INFO,"NEODisplayVideo\n");
+#endif
+    fmt = 0x00;
+    switch (id){
+    case FOURCC_YV12:
+    case FOURCC_I420:
+    case FOURCC_YUY2:
+	fmt = 0x00;
+	break;
+    case FOURCC_RV15:
+    case FOURCC_RV16:
+	fmt = 0x20;
+	break;
+    }
+	
+    if (drw_w > src_w){
+	hstretch = src_w * 0x1000 / drw_w;
+    } else {
+	hstretch = 0x1000;
+    }
+
+    if (drw_h > src_h){
+	vstretch = src_h * 0x0800 / drw_h;
+    } else {
+	vstretch = 0x0800;
+    }
+
+    OUTGR(0xb1, (((dstBox->x2-1)>>4)&0xf0)|((dstBox->x1>>8)&0x0f));
+    OUTGR(0xb2, dstBox->x1);
+    OUTGR(0xb3, dstBox->x2-1);
+    OUTGR(0xb4, (((dstBox->y2-1)>>4)&0xf0)|((dstBox->y1>>8)&0x0f));
+    OUTGR(0xb5, dstBox->y1);
+    OUTGR(0xb6, dstBox->y2-1);
+    OUTGR(0xb7, offset >> 17);
+    OUTGR(0xb8, offset >> 9);
+    OUTGR(0xb9, offset >> 1);
+    OUTGR(0xba, src_w >> 8);
+    OUTGR(0xbb, src_w);
+    OUTGR(0xbc, 0x4f);
+    OUTGR(0xc0, hstretch >> 8);
+    OUTGR(0xc1, hstretch);
+    OUTGR(0xc2, vstretch >> 8);
+    OUTGR(0xc3, vstretch);
+    OUTGR(0xbf, 0x02);
+    OUTGR(0xb0, fmt | 0x03);
+
+    OUTGR(0x0a, 0x21);
+    OUTSR(0x08, 0xa0);
+    OUTGR(0x0a, 0x01);
+}
+
+static void
+NEOInitOffscreenImages(ScreenPtr pScreen)
+{
+    XF86OffscreenImagePtr offscreenImages;
+
+#ifdef DEBUG
+    xf86DrvMsg(xf86Screens[pScreen->myNum]->scrnIndex,X_INFO,"NEOInitOffscreenImages\n");
+#endif
+    if ((offscreenImages = xalloc(sizeof(XF86OffscreenImageRec))) == NULL){
+	return;
+    }
+
+    offscreenImages->image = NEOVideoImages;
+    offscreenImages->flags = VIDEO_OVERLAID_IMAGES | VIDEO_CLIP_TO_VIEWPORT;
+    offscreenImages->alloc_surface = NEOAllocSurface;
+    offscreenImages->free_surface = NEOFreeSurface;
+    offscreenImages->display = NEODisplaySurface;
+    offscreenImages->stop = NEOStopSurface;
+    offscreenImages->getAttribute = NEOGetSurfaceAttribute;
+    offscreenImages->setAttribute = NEOSetSurfaceAttribute;
+    offscreenImages->max_width = 1024;
+    offscreenImages->max_height = 1024;
+    offscreenImages->num_attributes = nElems(NEOVideoAttributes);
+    offscreenImages->attributes = NEOVideoAttributes;
+
+    xf86XVRegisterOffscreenImages(pScreen, offscreenImages, 1);
+}
+
+static FBLinearPtr
+NEOAllocateMemory(ScrnInfoPtr pScrn, FBLinearPtr linear, int size)
+{
+    ScreenPtr pScreen;
+    FBLinearPtr new_linear;
+
+#ifdef DEBUG
+    xf86DrvMsg(pScrn->scrnIndex,X_INFO,"NEOAllocateMemory: linear=%x, size=%d\n", linear, size);
+#endif
+    if (linear){
+#ifdef DEBUG
+        xf86DrvMsg(pScrn->scrnIndex,X_INFO,"NEOAllocateMemory: linear->size=%d\n", linear->size);
+#endif
+	if (linear->size >= size){
+	    return (linear);
+	}
+
+	if (xf86ResizeOffscreenLinear(linear, size)){
+	    return (linear);
+	}
+
+	xf86FreeOffscreenLinear(linear);
+    }
+
+    pScreen = screenInfo.screens[pScrn->scrnIndex];
+    if ((new_linear = xf86AllocateOffscreenLinear(pScreen, size, 16, NULL, NULL, NULL)) == NULL){
+	int max_size;
+
+	xf86QueryLargestOffscreenLinear(pScreen, &max_size, 16, PRIORITY_EXTREME);
+#ifdef DEBUG
+        xf86DrvMsg(pScrn->scrnIndex,X_INFO,"NEOAllocateMemory: max_size=%d\n", max_size);
+#endif
+	if (max_size < size){
+	    return (NULL);
+	}
+
+	xf86PurgeUnlockedOffscreenAreas(pScreen);
+	new_linear = xf86AllocateOffscreenLinear(pScreen, size, 16, NULL, NULL, NULL);
+    }
+    return (new_linear);
+}
+
+static void
+NEOCopyData(unsigned char *src, unsigned char *dst, 
+	    int srcPitch, int dstPitch,
+	    int height, int width)
+{
+    while (height-- > 0){
+	memcpy(dst, src, width);
+	src += srcPitch;
+	dst += dstPitch;
+    }
+}
+
+static void
+NEOCopyYV12Data(unsigned char *src1, unsigned char *src2,
+		unsigned char *src3, unsigned char *dst,
+		int srcPitch1, int srcPitch2, int dstPitch,
+		int height, int width)
+{
+    CARD32 *pDst = (CARD32 *) dst;
+    int i, j;
+
+    for (j = 0; j < height; j++){
+	for (i =0; i < width; i++){
+	    pDst[i] = src1[i << 1] | (src1[(i << 1) + 1] << 16) |
+		(src3[i] << 8) | (src2[i] << 24);
+	}
+	pDst += dstPitch >> 2;
+	src1 += srcPitch1;
+	if (j & 1){
+	    src2 += srcPitch2;
+	    src3 += srcPitch2;
+	}
+    }
+}
+
+static int
+NEOAllocSurface(ScrnInfoPtr pScrn, int id, 
+		unsigned short width, unsigned short height,
+		XF86SurfacePtr surface)
+{
+    int pitch, bpp, size;
+    NEOOffscreenPtr pPriv;
+    FBLinearPtr linear;
+
+#ifdef DEBUG
+    xf86DrvMsg(pScrn->scrnIndex,X_INFO,"NEOAllocSurface\n");
+#endif
+    if (width > 1024  || height > 1024){
+	return (BadAlloc);
+    }
+
+    width = (width + 1) & ~1;
+    bpp = 2;
+    pitch = (width * bpp + 15) & ~15;
+    size = pitch * height;
+
+    if ((linear = NEOAllocateMemory(pScrn, NULL, size)) == NULL){
+	return (BadAlloc);
+    }
+
+    surface->width = width;
+    surface->height = height;
+    if ((surface->pitches = xalloc(sizeof(int))) == NULL){
+	xf86FreeOffscreenLinear(linear);
+	return (BadAlloc);
+    }
+    if ((surface->offsets = xalloc(sizeof(int))) == NULL){
+	xfree(surface->pitches);
+	xf86FreeOffscreenLinear(linear);
+	return (BadAlloc);
+    }
+
+    if ((pPriv = xalloc(sizeof(NEOOffscreenRec))) == NULL){
+	xfree(surface->pitches);
+	xfree(surface->offsets);
+	xf86FreeOffscreenLinear(linear);
+	return (BadAlloc);
+    }
+
+    pPriv->linear = linear;
+    pPriv->isOn = FALSE;
+
+    surface->pScrn = pScrn;
+    surface->id = id;
+    surface->pitches[0] = pitch;
+    surface->offsets[0] = linear->offset * bpp;
+    surface->devPrivate.ptr = (pointer)pPriv;
+    return (Success);
+}
+
+static int
+NEOFreeSurface(XF86SurfacePtr surface)
+{
+    NEOOffscreenPtr pPriv = (NEOOffscreenPtr)surface->devPrivate.ptr;
+
+#ifdef DEBUG
+    xf86DrvMsg(0,X_INFO,"NEOFreeSurface\n");
+#endif
+    if (pPriv->isOn)
+	NEOStopSurface(surface);
+
+    xf86FreeOffscreenLinear(pPriv->linear);
+    xfree(surface->pitches);
+    xfree(surface->offsets);
+    xfree(surface->devPrivate.ptr);
+    return (Success);
+}
+
+static int
+NEODisplaySurface(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)
+{
+    NEOOffscreenPtr pPriv = (NEOOffscreenPtr)surface->devPrivate.ptr;
+    NEOPtr nPtr = NEOPTR(surface->pScrn);
+    NEOPortPtr portPriv = nPtr->overlayAdaptor->pPortPrivates[0].ptr;
+    INT32 x1, y1, x2, y2;
+    BoxRec dstBox;
+
+#ifdef DEBUG
+    xf86DrvMsg(surface->pScrn->scrnIndex,X_INFO,"NEODisplaySurface\n");
+#endif
+    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 (!NEOClipVideo(surface->pScrn, &dstBox, &x1, &y1, &x2, &y2, clipBoxes,
+		      surface->width, surface->height)){
+	return (Success);
+    }
+
+    dstBox.x1 -= surface->pScrn->frameX0;
+    dstBox.y1 -= surface->pScrn->frameY0;
+    dstBox.x2 -= surface->pScrn->frameX0;
+    dstBox.y2 -= surface->pScrn->frameY0;
+
+    XAAFillSolidRects(surface->pScrn, portPriv->colorKey, GXcopy, ~0,
+		      REGION_NUM_RECTS(clipBoxes), REGION_RECTS(clipBoxes));
+
+    NEOResetVideo(surface->pScrn);
+    NEODisplayVideo(surface->pScrn, 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->video_status & CLIENT_VIDEO_ON){
+	REGION_EMPTY(pScrn->pScreen, &portPriv->clip);
+	UpdateCurrentTime();
+	portPriv->video_status = FREE_TIMER;
+	portPriv->freeTime = currentTime.milliseconds + FREE_DELAY;
+    }
+    return (Success);
+}
+
+static int
+NEOStopSurface(XF86SurfacePtr surface)
+{
+    NEOOffscreenPtr pPriv = (NEOOffscreenPtr)surface->devPrivate.ptr;
+
+#ifdef DEBUG
+    xf86DrvMsg(surface->pScrn->scrnIndex,X_INFO,"NEOStopSurface\n");
+#endif
+    if (pPriv->isOn){
+	NEOPtr nPtr = NEOPTR(surface->pScrn);
+	OUTGR(0xb0, 0x02);
+	pPriv->isOn = FALSE;
+    }
+    return (Success);
+}
+
+static int
+NEOGetSurfaceAttribute(ScrnInfoPtr pScrn, Atom attr, INT32 *value)
+{
+    NEOPtr nPtr = NEOPTR(pScrn);
+
+#ifdef DEBUG
+    xf86DrvMsg(pScrn->scrnIndex,X_INFO,"NEOGetSurfaceAttribute\n");
+#endif
+    return (NEOGetPortAttribute(pScrn, attr, value, (pointer)nPtr->overlayAdaptor->pPortPrivates[0].ptr));
+}
+
+static int
+NEOSetSurfaceAttribute(ScrnInfoPtr pScrn, Atom attr, INT32 value)
+{
+    NEOPtr nPtr = NEOPTR(pScrn);
+
+#ifdef DEBUG
+    xf86DrvMsg(pScrn->scrnIndex,X_INFO,"NEOSetSurfaceAttribute\n");
+#endif
+    return (NEOSetPortAttribute(pScrn, attr, value, (pointer)nPtr->overlayAdaptor->pPortPrivates[0].ptr));
+}
+#else /* XvExtension */
+void NEOInitVideo(ScreenPtr pScreen) {}
+#endif
diff -uNr neomagic.org/neo_video.h neomagic/neo_video.h
--- neomagic.org/neo_video.h	Thu Jan  1 09:00:00 1970
+++ neomagic/neo_video.h	Sat Feb  2 20:57:49 2002
@@ -0,0 +1,47 @@
+#ifndef _NEO_VIDEO_H
+#define _NEO_VIDEO_H
+
+#include "vgaHW.h"
+#include "fourcc.h"
+
+#define NEO_VIDEO_VIDEO		0
+#define NEO_VIDEO_IMAGE		1
+
+#define FOURCC_RV15			0x35315652
+#define FOURCC_RV16			0x36315652
+
+#define OFF_DELAY			200		/* milliseconds */
+#define FREE_DELAY			60000	/* milliseconds */
+
+#define OFF_TIMER			0x01
+#define FREE_TIMER			0x02
+#define CLIENT_VIDEO_ON		0x04
+#define TIMER_MASK			(OFF_TIMER | FREE_TIMER)
+
+typedef struct
+{
+    FBLinearPtr	linear;
+    RegionRec	clip;
+    CARD32	colorKey;
+    CARD32	brightness;
+    CARD32	video_status;
+    Time	offTime;
+    Time	freeTime;
+} NEOPortRec, *NEOPortPtr;
+
+typedef struct
+{
+    FBLinearPtr	linear;
+    Bool	isOn;
+} NEOOffscreenRec, *NEOOffscreenPtr;
+
+/* I/O Functions */
+#if 1
+#define OUTGR(idx,dat) (*(unsigned short *)(nPtr->NeoMMIOBase2+VGA_GRAPH_INDEX)=(idx)|((dat)<<8))
+#define INGR(idx) (*(nPtr->NeoMMIOBase2+VGA_GRAPH_INDEX)=(idx), *(nPtr->NeoMMIOBase2+VGA_GRAPH_DATA))
+#else
+#define OUTGR(idx,dat) VGAwGR((idx),(dat))
+#endif
+#define OUTSR(idx,dat) (*(unsigned short *)(nPtr->NeoMMIOBase2+VGA_SEQ_INDEX)=(idx)|((dat)<<8))
+#define INSR(idx) (*(nPtr->NeoMMIOBase2+VGA_SEQ_INDEX)=(idx), *(nPtr->NeoMMIOBase2+VGA_SEQ_DATA))
+#endif /* _NEO_VIDEO_H */