4 * Copyright (C) Colin Cross Apr 2000
6 * This file heavily based off of video_out_mga.c of Aaron Holtzman's
9 * mpeg2dec is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2, or (at your option)
14 * mpeg2dec is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with mpeg2dec; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31 #include "video_out.h"
32 #include "video_out_internal.h"
33 #include "x11_common.h"
35 #include <sys/ioctl.h>
44 #include <X11/extensions/xf86dga.h>
45 #include <X11/Xutil.h>
47 //#define LOG(x) syslog(LOG_USER | LOG_DEBUG,x)
50 #include "drivers/3dfx.h"
52 #include "fastmemcpy.h"
54 static const vo_info_t info
=
58 "Colin Cross <colin@MIT.EDU>",
62 const LIBVO_EXTERN(3dfx
)
64 static uint32_t is_fullscreen
= 1;
66 static uint32_t vidwidth
;
67 static uint32_t vidheight
;
69 static uint32_t screenwidth
;
70 static uint32_t screenheight
;
71 static uint32_t screendepth
= 2; //Only 16bpp supported right now
73 static uint32_t dispwidth
= 1280; // You can change these to whatever you want
74 static uint32_t dispheight
= 720; // 16:9 screen ratio??
75 static uint32_t dispx
;
76 static uint32_t dispy
;
78 static uint32_t *vidpage0
;
79 static uint32_t *vidpage1
;
80 static uint32_t *vidpage2
;
82 static uint32_t vidpage0offset
;
83 static uint32_t vidpage1offset
;
84 static uint32_t vidpage2offset
;
86 // Current pointer into framebuffer where display is located
87 static uint32_t targetoffset
;
89 static uint32_t page_space
;
91 static voodoo_io_reg
*reg_IO
;
92 static voodoo_2d_reg
*reg_2d
;
93 static voodoo_yuv_reg
*reg_YUV
;
94 static voodoo_yuv_fb
*fb_YUV
;
96 static uint32_t *memBase0
, *memBase1
;
97 static uint32_t baseAddr0
, baseAddr1
;
100 /* X11 related variables */
101 static Display
*display
;
102 static Window mywindow
;
104 static XWindowAttributes attribs
;
112 //reg_IO->vidDesktopStartAddr = vidpage0offset;
113 XF86DGADirectVideo(display
,0,0);
119 //reg_IO->vidDesktopStartAddr = vidpage0offset;
120 XF86DGADirectVideo(display
,0,0);
125 restore_regs(voodoo_2d_reg
*regs
)
127 reg_2d
->commandExtra
= regs
->commandExtra
;
128 reg_2d
->clip0Min
= regs
->clip0Min
;
129 reg_2d
->clip0Max
= regs
->clip0Max
;
131 reg_2d
->srcBaseAddr
= regs
->srcBaseAddr
;
132 reg_2d
->srcXY
= regs
->srcXY
;
133 reg_2d
->srcFormat
= regs
->srcFormat
;
134 reg_2d
->srcSize
= regs
->srcSize
;
136 reg_2d
->dstBaseAddr
= regs
->dstBaseAddr
;
137 reg_2d
->dstXY
= regs
->dstXY
;
138 reg_2d
->dstFormat
= regs
->dstFormat
;
140 reg_2d
->dstSize
= regs
->dstSize
;
145 create_window(Display
*display
, char *title
)
154 XSetWindowAttributes xswa
;
155 unsigned long xswamask
;
157 screen
= DefaultScreen(display
);
161 hint
.width
= dispwidth
;
162 hint
.height
= dispheight
;
163 hint
.flags
= PPosition
| PSize
;
165 bg
= WhitePixel(display
, screen
);
166 fg
= BlackPixel(display
, screen
);
168 XGetWindowAttributes(display
, DefaultRootWindow(display
), &attribs
);
172 mp_msg(MSGT_VO
,MSGL_WARN
, MSGTR_LIBVO_3DFX_Only16BppSupported
);
176 XMatchVisualInfo(display
,screen
,bpp
,TrueColor
,&vinfo
);
177 mp_msg(MSGT_VO
,MSGL_INFO
, MSGTR_LIBVO_3DFX_VisualIdIs
,vinfo
.visualid
);
179 theCmap
= XCreateColormap(display
, RootWindow(display
,screen
),
180 vinfo
.visual
, AllocNone
);
182 xswa
.background_pixel
= 0;
183 xswa
.border_pixel
= 1;
184 xswa
.colormap
= theCmap
;
185 xswamask
= CWBackPixel
| CWBorderPixel
|CWColormap
;
188 mywindow
= XCreateWindow(display
, RootWindow(display
,screen
),
189 hint
.x
, hint
.y
, hint
.width
, hint
.height
, 4, bpp
,CopyFromParent
,vinfo
.visual
,xswamask
,&xswa
);
190 vo_x11_classhint( display
,mywindow
,"3dfx" );
192 XSelectInput(display
, mywindow
, StructureNotifyMask
);
194 /* Tell other applications about this window */
196 XSetStandardProperties(display
, mywindow
, title
, title
, None
, NULL
, 0, &hint
);
200 XMapWindow(display
, mywindow
);
205 XNextEvent(display
, &xev
);
207 while (xev
.type
!= MapNotify
|| xev
.xmap
.event
!= mywindow
);
209 XSelectInput(display
, mywindow
, NoEventMask
);
211 XSync(display
, False
);
217 dump_yuv_planar(uint32_t *y
, uint32_t *u
, uint32_t *v
, uint32_t to
, uint32_t width
, uint32_t height
)
219 // YUV conversion works like this:
221 // We write the Y, U, and V planes separately into 3dfx YUV Planar memory
222 // region. The nice chip then takes these and packs them into the YUYV
223 // format in the regular frame buffer, starting at yuvBaseAddr, page 2 here.
224 // Then we tell the 3dfx to do a Screen to Screen Stretch BLT to copy all
225 // of the data on page 2 onto page 1, converting it to 16 bpp RGB as it goes.
226 // The result is a nice image on page 1 ready for display.
229 uint32_t y_imax
, uv_imax
, jmax
;
231 reg_YUV
->yuvBaseAddr
= to
;
232 reg_YUV
->yuvStride
= screenwidth
*2;
234 LOG("video_out_3dfx: starting planar dump\n");
235 jmax
= height
>>1; // vidheight/2, height of U and V planes
236 y_imax
= width
; // Y plane is twice as wide as U and V planes
237 uv_imax
= width
>>1; // vidwidth/2/4, width of U and V planes in 32-bit words
241 //XXX this should be hand-rolled 32 bit memcpy for safeness.
242 fast_memcpy(fb_YUV
->U
+ (uint32_t) VOODOO_YUV_STRIDE
* j
,((uint8_t*) u
) + uv_imax
* j
, uv_imax
);
243 fast_memcpy(fb_YUV
->V
+ (uint32_t) VOODOO_YUV_STRIDE
* j
,((uint8_t*) v
) + uv_imax
* j
, uv_imax
);
244 fast_memcpy(fb_YUV
->Y
+ (uint32_t) VOODOO_YUV_STRIDE
* (j
<<1) ,((uint8_t*) y
) + y_imax
* (j
<<1) , y_imax
);
245 fast_memcpy(fb_YUV
->Y
+ (uint32_t) VOODOO_YUV_STRIDE
*((j
<<1)+1),((uint8_t*) y
) + y_imax
*((j
<<1)+1), y_imax
);
247 LOG("video_out_3dfx: done planar dump\n");
251 screen_to_screen_stretch_blt(uint32_t to
, uint32_t from
, uint32_t width
, uint32_t height
)
253 //FIXME - this function should be called by a show_frame function that
254 // uses a series of blts to show only those areas not covered
256 voodoo_2d_reg saved_regs
;
258 LOG("video_out_3dfx: saving registers\n");
259 // Save VGA regs (so X kinda works when we're done)
260 saved_regs
= *reg_2d
;
262 /* The following lines set up the screen to screen stretch blt from page2 to
266 LOG("video_out_3dfx: setting blt registers\n");
267 reg_2d
->commandExtra
= 4; //disable colorkeying, enable wait for v-refresh (0100b)
268 reg_2d
->clip0Min
= 0;
269 reg_2d
->clip0Max
= 0xFFFFFFFF; //no clipping
271 reg_2d
->srcBaseAddr
= from
;
273 reg_2d
->srcFormat
= screenwidth
*2 | VOODOO_BLT_FORMAT_YUYV
; // | 1<<21;
274 reg_2d
->srcSize
= vidwidth
| (vidheight
<< 16);
276 reg_2d
->dstBaseAddr
= to
;
278 reg_2d
->dstFormat
= screenwidth
*2 | VOODOO_BLT_FORMAT_16
;
280 reg_2d
->dstSize
= width
| (height
<< 16);
282 LOG("video_out_3dfx: starting blt\n");
283 // Executes screen to screen stretch blt
284 reg_2d
->command
= 2 | 1<<8 | 0xCC<<24;
286 LOG("video_out_3dfx: restoring regs\n");
287 restore_regs(&saved_regs
);
289 LOG("video_out_3dfx: done blt\n");
295 uint32_t xp
, yp
, w
, h
, b
, d
;
298 XGetGeometry(display
,mywindow
,&root
,&xp
,&yp
,&w
,&h
,&b
,&d
);
299 XTranslateCoordinates(display
,mywindow
,root
,0,0,&xp
,&yp
,&root
);
300 dispx
= (uint32_t) xp
;
301 dispy
= (uint32_t) yp
;
302 dispwidth
= (uint32_t) w
;
303 dispheight
= (uint32_t) h
;
306 targetoffset
= vidpage0offset
+ (screenheight
- dispheight
)/2*screenwidth
*screendepth
+ (screenwidth
-dispwidth
)/2*screendepth
;
308 targetoffset
= vidpage0offset
+ (dispy
*screenwidth
+ dispx
)*screendepth
;
312 config(uint32_t width
, uint32_t height
, uint32_t d_width
, uint32_t d_height
, uint32_t fullscreen
, char *title
, uint32_t format
)
318 //TODO use x11_common for X and window handling
320 if(getenv("DISPLAY"))
321 name
= getenv("DISPLAY");
322 display
= XOpenDisplay(name
);
324 screenwidth
= XDisplayWidth(display
,0);
325 screenheight
= XDisplayHeight(display
,0);
327 page_space
= screenwidth
*screenheight
*screendepth
;
329 vidpage1offset
= page_space
; // Use third and fourth pages
330 vidpage2offset
= page_space
*2;
332 signal(SIGALRM
,sighup
);
335 // Open driver device
338 mp_msg(MSGT_VO
,MSGL_WARN
, MSGTR_LIBVO_3DFX_UnableToOpenDevice
);
342 // Store sizes for later
346 is_fullscreen
= fullscreen
= 0;
348 create_window(display
, title
);
350 // Ask 3dfx driver for base memory address 0
351 data
.port
= 0x10; // PCI_BASE_ADDRESS_0_LINUX;
353 data
.value
= &baseAddr0
;
355 if ((retval
= ioctl(fd
,_IOC(_IOC_READ
,'3',3,0),&data
)) < 0)
357 mp_msg(MSGT_VO
,MSGL_WARN
, MSGTR_LIBVO_3DFX_Error
,retval
);
361 // Ask 3dfx driver for base memory address 1
362 data
.port
= 0x14; // PCI_BASE_ADDRESS_1_LINUX;
364 data
.value
= &baseAddr1
;
366 if ((retval
= ioctl(fd
,_IOC(_IOC_READ
,'3',3,0),&data
)) < 0)
368 mp_msg(MSGT_VO
,MSGL_WARN
, MSGTR_LIBVO_3DFX_Error
,retval
);
372 // Map all 3dfx memory areas
373 memBase0
= mmap(0,0x1000000,PROT_READ
| PROT_WRITE
,MAP_SHARED
,fd
,baseAddr0
);
374 memBase1
= mmap(0,3*page_space
,PROT_READ
| PROT_WRITE
,MAP_SHARED
,fd
,baseAddr1
);
375 if (memBase0
== (uint32_t *) 0xFFFFFFFF || memBase1
== (uint32_t *) 0xFFFFFFFF)
377 mp_msg(MSGT_VO
,MSGL_WARN
, MSGTR_LIBVO_3DFX_CouldntMapMemoryArea
,
378 memBase0
,memBase1
,errno
);
381 // Set up global pointers
382 reg_IO
= (void *)memBase0
+ VOODOO_IO_REG_OFFSET
;
383 reg_2d
= (void *)memBase0
+ VOODOO_2D_REG_OFFSET
;
384 reg_YUV
= (void *)memBase0
+ VOODOO_YUV_REG_OFFSET
;
385 fb_YUV
= (void *)memBase0
+ VOODOO_YUV_PLANE_OFFSET
;
387 vidpage0
= (void *)memBase1
+ (unsigned long int)vidpage0offset
;
388 vidpage1
= (void *)memBase1
+ (unsigned long int)vidpage1offset
;
389 vidpage2
= (void *)memBase1
+ (unsigned long int)vidpage2offset
;
392 // leave page 0, that belongs to X.
393 // So does part of 1. Oops.
394 memset(vidpage1
,0x00,page_space
);
395 memset(vidpage2
,0x00,page_space
);
398 memset(vidpage0
,0x00,page_space
);
402 // Show page 0 (unblanked)
403 reg_IO
->vidDesktopStartAddr
= vidpage0offset
;
405 /* Stop X from messing with my video registers!
406 Find a better way to do this?
407 Currently I use DGA to tell XF86 to not screw with registers, but I can't really use it
408 to do FB stuff because I need to know the absolute FB position and offset FB position
409 to feed to BLT command
411 //XF86DGADirectVideo(display,0,XF86DGADirectGraphics); //| XF86DGADirectMouse | XF86DGADirectKeyb);
416 mp_msg(MSGT_VO
,MSGL_INFO
, MSGTR_LIBVO_3DFX_DisplayInitialized
,memBase1
);
421 draw_frame(uint8_t *src
[])
423 LOG("video_out_3dfx: starting display_frame\n");
425 // Put packed data onto page 2
426 dump_yuv_planar((uint32_t *)src
[0],(uint32_t *)src
[1],(uint32_t *)src
[2],
427 vidpage2offset
,vidwidth
,vidheight
);
429 LOG("video_out_3dfx: done display_frame\n");
434 //draw_slice(uint8_t *src[], uint32_t slice_num)
435 draw_slice(uint8_t *src
[], int stride
[], int w
,int h
,int x
,int y
)
439 target
= vidpage2offset
+ (screenwidth
*2 * y
);
440 dump_yuv_planar((uint32_t *)src
[0],(uint32_t *)src
[1],(uint32_t *)src
[2],target
,vidwidth
,h
);
444 static void draw_osd(void)
451 //FIXME - update_target() should be called by event handler when window
452 // is resized or moved
454 LOG("video_out_3dfx: calling blt function\n");
455 screen_to_screen_stretch_blt(targetoffset
, vidpage2offset
, dispwidth
, dispheight
);
459 query_format(uint32_t format
)
461 /* does this supports scaling? up & down? */
465 // case IMGFMT_RGB|24:
466 // case IMGFMT_BGR|24:
467 return VFCAP_CSP_SUPPORTED
|VFCAP_CSP_SUPPORTED_BY_HW
;
480 static void check_events(void)
484 static int preinit(const char *arg
)
486 if ( (fd
= open("/dev/3dfx",O_RDWR
) ) == -1)
488 mp_msg(MSGT_VO
,MSGL_WARN
, MSGTR_LIBVO_3DFX_UnableToOpenDevice
);
494 mp_msg(MSGT_VO
,MSGL_WARN
, MSGTR_LIBVO_3DFX_UnknownSubdevice
,arg
);
500 static int control(uint32_t request
, void *data
, ...)
503 case VOCTRL_QUERY_FORMAT
:
504 return query_format(*((uint32_t*)data
));