# HG changeset patch # User arpi # Date 1001593434 0 # Node ID 6278f566cd9177b2489ace107a2fee83932efbd0 # Parent 6e798c58d457b4f9d3c03d16154e9c914dad94a8 tdfxfb yuv driver by Zeljko Stevanovic diff -r 6e798c58d457 -r 6278f566cd91 configure --- a/configure Thu Sep 27 12:22:27 2001 +0000 +++ b/configure Thu Sep 27 12:23:54 2001 +0000 @@ -473,6 +473,7 @@ _xdpms_3=no _xdpms_4=no _3dfx=no +_tdfxfb=no _syncfb=no _mlib=no _mlibdir=/opt/SUNWmlib _xmga=autodetect @@ -1167,6 +1168,9 @@ --enable-3dfx) _3dfx=yes ;; + --enable-tdfxfb) + _tdfxfb=yes + ;; --enable-syncfb) _syncfb=yes ;; @@ -2065,6 +2069,13 @@ _3dfx='#undef HAVE_3DFX' fi +if [ $_tdfxfb = yes ]; then + _tdfxfb='#define HAVE_TDFXFB' + _vosrc=$_vosrc' vo_tdfxfb.c' +else + _tdfxfb='#undef HAVE_TDFXFB' +fi + if [ $_svga = yes ]; then _svga='#define HAVE_SVGALIB' _vosrc=$_vosrc' vo_svga.c' @@ -2375,6 +2386,7 @@ $_sdlbuggy $_ggi $_3dfx +$_tdfxfb $_mga $_xmga $_syncfb diff -r 6e798c58d457 -r 6278f566cd91 libvo/video_out.c --- a/libvo/video_out.c Thu Sep 27 12:22:27 2001 +0000 +++ b/libvo/video_out.c Thu Sep 27 12:23:54 2001 +0000 @@ -57,6 +57,7 @@ extern vo_functions_t video_out_fsdga; extern vo_functions_t video_out_sdl; extern vo_functions_t video_out_3dfx; +extern vo_functions_t video_out_tdfxfb; extern vo_functions_t video_out_null; extern vo_functions_t video_out_odivx; extern vo_functions_t video_out_pgm; @@ -83,6 +84,9 @@ #ifdef HAVE_3DFX &video_out_3dfx, #endif +#ifdef HAVE_TDFXFB + &video_out_tdfxfb, +#endif #ifdef HAVE_XV &video_out_xv, #endif diff -r 6e798c58d457 -r 6278f566cd91 libvo/vo_tdfxfb.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libvo/vo_tdfxfb.c Thu Sep 27 12:23:54 2001 +0000 @@ -0,0 +1,801 @@ + +/* + * video_out_tdfxfb.c + * + * Copyright (C) Zeljko Stevanovic 2001, + * + * Most code rewrited, move from /dev/3dfx to /dev/fb0 (kernel 2.4.?) + * add support for YUY2 and BGR16 format, remove all X11 DGA code. + * + * Copyright (C) Colin Cross Apr 2000 + * + * This file heavily based off of video_out_mga.c of Aaron Holtzman's + * mpeg2dec + * + * mpeg2dec is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * mpeg2dec is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNU Make; see the file COPYING. If not, write to + * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + +#include +#include +#include + +#include "config.h" +#include "video_out.h" +#include "video_out_internal.h" + +LIBVO_EXTERN(tdfxfb) + +#include +#include +#include +#include +#include +#include +#include + +#include + +extern int verbose; + +//#define LOG(x) syslog(LOG_USER | LOG_DEBUG,x) +#define LOG(x) + +#include "drivers/3dfx.h" + +#include "fastmemcpy.h" + +static vo_info_t vo_info = +{ + "tdfxfb (/dev/fb?)", + "tdfxfb", + "Zeljko Stevanovic , bassed on vo_3dfx of Colin Cross ", + "" +}; + +static char *fb_devname = NULL; +static int fb_fd = -1; +static struct fb_fix_screeninfo fb_finfo; +static struct fb_var_screeninfo fb_vinfo; + +static uint32_t in_width; +static uint32_t in_height; +static uint32_t in_format; +static uint32_t in_bytepp; + +static uint32_t in_banshee_format, + in_banshee_size; + +static uint32_t screenwidth; +static uint32_t screenheight; +static uint32_t screendepth; +static uint32_t vidwidth, vidheight; // resize on screen to ... for ration expect... +static uint32_t vidx=0, vidy=0; // for centring on screen. + +static uint32_t vid_banshee_xy, + vid_banshee_format, + vid_banshee_size; + +static void (*draw_alpha_p)(int w, int h, unsigned char *src, + unsigned char *srca, int stride, unsigned char *dst, + int dstride); + +static uint32_t *vidpage0; +static uint32_t *vidpage1; +static uint32_t *osd_page; +static uint32_t *in_page0; + +static uint32_t vidpage0offset; +static uint32_t vidpage1offset; +static uint32_t osd_page_offset; +static uint32_t in_page0_offset; + +// Current pointer into framebuffer where display is located +static uint32_t targetoffset; + +static uint32_t page_space; + +static uint32_t *tdfx_iobase; + +static voodoo_io_reg *reg_IO; +static voodoo_2d_reg *reg_2d; +static voodoo_yuv_reg *reg_YUV; +static voodoo_yuv_fb *fb_YUV; + +static uint32_t *memBase0, *memBase1; +//static uint32_t baseAddr0, baseAddr1; + +//#define BANSHEE_SCREEN_MEMORY (8*1024*1024) +//static uint32_t tdfx_free_scrmem = 0; + +/*- ----------------------------------------------------------------- -*/ + +/* code get from linux kernel tdfxfb.c by Hannu Mallat */ + +typedef uint32_t u32; + +static inline u32 tdfx_inl(unsigned int reg) { + return *((volatile uint32_t *)(tdfx_iobase + reg)); +} + +static inline void tdfx_outl(unsigned int reg, u32 val) { + *((volatile uint32_t *)(tdfx_iobase + reg)) = val; +} + +static inline void banshee_make_room(int size) { + while((tdfx_inl(STATUS) & 0x1f) < size); +} + +static inline void banshee_wait_idle(void) +{ + int i = 0; + + banshee_make_room(1); + tdfx_outl(COMMAND_3D, COMMAND_3D_NOP); + + while(1) { + i = (tdfx_inl(STATUS) & STATUS_BUSY) ? 0 : i + 1; + if(i == 3) break; + } +} + + +/*- ----------------------------------------------------------------- -*/ + +static void +restore_regs(voodoo_2d_reg *regs) +{ + reg_2d->commandExtra = regs->commandExtra; + reg_2d->clip0Min = regs->clip0Min; + reg_2d->clip0Max = regs->clip0Max; + + reg_2d->srcBaseAddr = regs->srcBaseAddr; + reg_2d->srcXY = regs->srcXY; + reg_2d->srcFormat = regs->srcFormat; + reg_2d->srcSize = regs->srcSize; + + reg_2d->dstBaseAddr = regs->dstBaseAddr; + reg_2d->dstXY = regs->dstXY; + reg_2d->dstFormat = regs->dstFormat; + + reg_2d->dstSize = regs->dstSize; + reg_2d->command = 0; +} + + +static void +restore(void) +{ + //reg_IO->vidDesktopStartAddr = vidpage0offset; + //XF86DGADirectVideo(display,0,0); +} + +static void +sighup(int foo) +{ + //reg_IO->vidDesktopStartAddr = vidpage0offset; + //XF86DGADirectVideo(display,0,0); + exit(0); +} + +#if 1 +static void +dump_yuv_planar(void *y, void *u, void *v, + uint32_t to, uint32_t px, uint32_t py, uint32_t width, uint32_t height) +{ + // YUV conversion works like this: + // + // We write the Y, U, and V planes separately into 3dfx YUV Planar memory + // region. The nice chip then takes these and packs them into the YUYV + // format in the regular frame buffer, starting at yuvBaseAddr, page 2 here. + // Then we tell the 3dfx to do a Screen to Screen Stretch BLT to copy all + // of the data on page 2 onto page 1, converting it to 16 bpp RGB as + // it goes. The result is a nice image on page 1 ready for display. + + uint32_t j; + uint32_t y_imax, uv_imax, jmax; + + + //printf("dump_yuv_planar(..., px=%d, py=%d, w=%d, h=%d\n", + // px, py, width, height); + + reg_YUV->yuvBaseAddr = to + in_width * 2 * py; + reg_YUV->yuvStride = width*2; + + jmax = height >> 1; // vidheight/2, height of U and V planes + y_imax = width; // Y plane is twice as wide as U and V planes + uv_imax = width >> 1; // in_width/2/4, width of U and V planes in 32-bit words + + for (j = 0; j < jmax; j++) + { +#if 0 + //XXX this should be hand-rolled 32 bit memcpy for safeness. + memcpy(fb_YUV->U (uint32_t) VOODOO_YUV_STRIDE * j, + ((uint8_t*)u) + uv_imax * j , uv_imax); + + memcpy(fb_YUV->V + (uint32_t) VOODOO_YUV_STRIDE * j, + ((uint8_t*)v) + uv_imax * j , uv_imax); + + memcpy(fb_YUV->Y + (uint32_t) VOODOO_YUV_STRIDE* (j<<1), + ((uint8_t*)y) + y_imax * (j<<1) , y_imax); + memcpy(fb_YUV->Y + (uint32_t) VOODOO_YUV_STRIDE*((j<<1)+1), + ((uint8_t*)y) + y_imax *((j<<1)+1), y_imax); +#else + memcpy(&fb_YUV->U[VOODOO_YUV_STRIDE * j], u + uv_imax * j , uv_imax); + memcpy(&fb_YUV->V[VOODOO_YUV_STRIDE * j], v + uv_imax * j , uv_imax); + + + memcpy(&fb_YUV->Y[VOODOO_YUV_STRIDE* (j<<1)], y + y_imax * (j<<1) , y_imax); + memcpy(&fb_YUV->Y[VOODOO_YUV_STRIDE*((j<<1)+1)], y + y_imax *((j<<1)+1), y_imax); +#endif + } +} +#endif + +#define S2S_BLT(cmd, to, dXY, dFmt, dSize, from, sXY, sFmt, sSize) \ + do { \ + voodoo_2d_reg saved_regs = *reg_2d; \ + \ + reg_2d->commandExtra = 0; \ + reg_2d->clip0Min = 0; \ + reg_2d->clip0Max = 0xffffffff; \ + \ + reg_2d->srcBaseAddr = (from); \ + reg_2d->srcXY = (sXY); \ + reg_2d->srcFormat = (sFmt); \ + reg_2d->srcSize = (sSize); \ + \ + reg_2d->dstBaseAddr = (to); \ + reg_2d->dstXY = (dXY); \ + reg_2d->dstFormat = (dFmt); \ + reg_2d->dstSize = (dSize); \ + \ + reg_2d->command = (cmd); \ + \ + restore_regs(&saved_regs); \ + } while (0) + + +#define VOODOO_BLT_FORMAT_24 (4 << 16) + +/*- ----------------------------------------------------------------- -*/ + +static uint32_t draw_slice_YV12(uint8_t *image[], int stride[], int w,int h,int x,int y); +static uint32_t draw_frame_YV12(uint8_t *src[]); +static void flip_page_YV12(void); +static void draw_osd_YV12(void); + +static uint32_t draw_slice_YUY2_BGR16(uint8_t *image[], int stride[], int w,int h,int x,int y); +static uint32_t draw_frame_YUY2_BGR16(uint8_t *src[]); +static void flip_page_YUY2_BGR16(void); +static void draw_osd_YUY2_BGR16(void); + +#if 0 +static uint32_t draw_frame_YUY2_2(uint8_t *src[]); +static uint32_t draw_slice_YUY2(uint8_t *image[], int stride[], int w,int h,int x,int y); +static void flip_page_all(void); +static void flip_page_YUY2(void); +static void flip_page_YUY2_2(void); +#endif + +static void draw_alpha(int x0, int y0, int w, int h, unsigned char *src, + unsigned char *srca, int stride); + +static void +update_target(void) +{ +} + +#ifndef VO_3DFX_METHOD +#define VO_3DFX_METHOD 1 +#endif + + +#if VO_3DFX_METHOD == 2 +extern void **our_out_buffer; +#endif + +static uint32_t +init(uint32_t width, uint32_t height, uint32_t d_width, uint32_t d_height, + uint32_t fullscreen, char *title, uint32_t format) +{ + + if (!fullscreen) return -1; + if (1 || verbose) { + printf("vo_3dfx->init( width = %d, height = %d, " + "d_width = %d, d_height = %d, format = %d)\n", + width, height, d_width, d_height, format); + printf("vo_3dfx->init( format => %s )\n", vo_format_name(format)); + printf("vo_3dfx: vo_depthonscreen => %d, vo_screenwidth => %d, " + "vo_screenhight => %d\n", vo_depthonscreen, vo_screenwidth, vo_screenheight); + printf("vo_3dfx->init() vo_dwidth => %d, vo_dheight => %d, vo_dbpp => %d\n", + vo_dwidth, vo_dheight, vo_dbpp); + } + + if (!fb_devname && !(fb_devname = getenv("FRAMEBUFFER"))) + fb_devname = "/dev/fb0"; + + if (1 || verbose) + printf("vo_3dfx->init(): fbdev ==> %s\n", fb_devname); + + if ((fb_fd = open(fb_devname, O_RDWR)) == -1) { + printf("vo_3dfx->init(): can't open %s, %s\n", fb_devname, strerror(errno)); + return -1; + } + + if (ioctl(fb_fd, FBIOGET_FSCREENINFO, &fb_finfo)) { + printf("vo_3dfx->init(): problem with ioctl(fb_fd, FBITGET_FSCREENINFO.., %s\n", + strerror(errno)); + return -1; + } + + if (ioctl(fb_fd, FBIOGET_VSCREENINFO, &fb_vinfo)) { + printf("vo_3dfx->init(): problem with ioctl(fb_fd, FBITGET_VSCREENINFO.., %s\n", + strerror(errno)); + return -1; + } + + if (verbose) { + printf("fb_finfo:\n"); + printf(" id: %s\n", fb_finfo.id); + printf(" frame bufer at %x len %x (%d)\n", fb_finfo.smem_start, fb_finfo.smem_len, + fb_finfo.smem_len); + printf(" mem io at %x len %x\n", fb_finfo.mmio_start, fb_finfo.mmio_len); + + printf("fb_vinfo:\n"); + printf(" resolution: %dx%d\n", fb_vinfo.xres, fb_vinfo.yres); + printf(" virtual res: %dx%d\n", fb_vinfo.xres_virtual, fb_vinfo.yres_virtual); + printf(" virt offset: %dx%d\n", fb_vinfo.xoffset, fb_vinfo.yoffset); + } + + if (fb_finfo.accel != FB_ACCEL_3DFX_BANSHEE) { + printf("vo_3dfx->init(): this driver made only for 3dfx banshee... sorry...\n"); + return -1; + } + if (fb_vinfo.bits_per_pixel != 16) { + printf("vo_3dfx->init(): for now fork only in 16 bits mode. use fbset -depth 16 \n"); + return -1; + } + //return -1; + + + //screenwidth = 800; + //screenheight = 600; + //screendepth = 2; + screenwidth = fb_vinfo.xres; + screenheight = fb_vinfo.yres; + screendepth = 2; + // Store sizes for later + in_width = width; + in_height = height; + in_format = format; + + vidwidth = screenwidth; + vidheight = screenheight; + //vidwidth = in_width; + //vidheight = in_height; + if (1) { + double exrat; + + exrat = (double)in_width / in_height; + if (verbose) + printf("vo_3dfx->init(): in_width / in_height => %f\n", exrat); + if (screenwidth / exrat <= screenheight) + vidheight = (double)screenwidth / exrat; + else + vidwidth = (double)screenheight * exrat; + + vidx = (screenwidth - vidwidth) / 2; + vidy = (screenheight - vidheight) / 2; + + if (verbose) { + printf("vo_3dfx->init(): vidwidth => %d\n", vidwidth); + printf("vo_3dfx->init(): vidheight => %d\n", vidheight); + printf("vo_3dfx->init(): vidx => %d\n", vidx); + printf("vo_3dfx->init(): vidy => %d\n", vidy); + } + } + + signal(SIGALRM,sighup); + //alarm(120); + + + // access to 3dfx hardware.... + memBase1 = mmap(0, fb_finfo.smem_len, PROT_READ | PROT_WRITE, + MAP_SHARED, fb_fd, 0); + memBase0 = mmap(0, fb_finfo.mmio_len, PROT_READ | PROT_WRITE, + MAP_SHARED, fb_fd, fb_finfo.smem_len); + + if (memBase0 == (uint32_t *)0xFFFFFFFF || + memBase1 == (uint32_t *)0xFFFFFFFF) + { + printf("Couldn't map 3dfx memory areas: %p, %p, %d\n", + memBase0, memBase1, errno); + } + + + tdfx_iobase = (void *)memBase0 + VOODOO_IO_REG_OFFSET; + + // Set up global pointers + reg_IO = (void *)memBase0 + VOODOO_IO_REG_OFFSET; + reg_2d = (void *)memBase0 + VOODOO_2D_REG_OFFSET; + reg_YUV = (void *)memBase0 + VOODOO_YUV_REG_OFFSET; + fb_YUV = (void *)memBase0 + VOODOO_YUV_PLANE_OFFSET; + + vidpage0offset = 0; + vidpage1offset = screenwidth * screenheight * screendepth; + //osd_page_offset = vidpage1offset + screenwidth * screenheight * screendepth; + //in_page0_offset = osd_page_offset + screenwidth * screenheight * screendepth; + in_page0_offset = vidpage1offset + screenwidth * screenheight * screendepth; + + vidpage0 = (void *)memBase1 + (unsigned long int)vidpage0offset; + vidpage1 = (void *)memBase1 + (unsigned long int)vidpage1offset; + //osd_page = (void *)memBase1 + (unsigned long int)osd_page_offset; + in_page0 = (void *)memBase1 + (unsigned long int)in_page0_offset; + + vid_banshee_xy = XYREG(vidx, vidy); + vid_banshee_format = screenwidth*2 | VOODOO_BLT_FORMAT_16; + vid_banshee_size = XYREG(vidwidth, vidheight); + + in_banshee_size = XYREG(in_width, in_height); + + //video_out_tdfxfb.flip_page = flip_page_all; + draw_alpha_p = NULL; + + switch (in_format) { + case IMGFMT_YV12: + video_out_tdfxfb.draw_slice = draw_slice_YV12; + video_out_tdfxfb.draw_frame = draw_frame_YV12; + video_out_tdfxfb.flip_page = flip_page_YV12; + video_out_tdfxfb.draw_osd = draw_osd_YV12; + in_banshee_format = in_width * 2 | VOODOO_BLT_FORMAT_YUYV; + break; + case IMGFMT_YUY2: + video_out_tdfxfb.draw_slice = draw_slice_YUY2_BGR16; + video_out_tdfxfb.draw_frame = draw_frame_YUY2_BGR16; + video_out_tdfxfb.flip_page = flip_page_YUY2_BGR16; + video_out_tdfxfb.draw_osd = draw_osd_YUY2_BGR16; + +#if VO_3DFX_METHOD == 1 + draw_alpha_p = vo_draw_alpha_yuy2; +#endif +#if VO_3DFX_METHOD == 2 + *our_out_buffer = in_page0; + draw_alpha_p = vo_draw_alpha_rgb16; +#endif + in_banshee_format = in_width * 2 | VOODOO_BLT_FORMAT_YUYV; + in_bytepp = 2; + break; + case IMGFMT_BGR|16: + video_out_tdfxfb.draw_slice = draw_slice_YUY2_BGR16; + video_out_tdfxfb.draw_frame = draw_frame_YUY2_BGR16; + video_out_tdfxfb.flip_page = flip_page_YUY2_BGR16; + video_out_tdfxfb.draw_osd = draw_osd_YUY2_BGR16; +#if VO_3DFX_METHOD == 2 + *our_out_buffer = in_page0; +#endif + draw_alpha_p = vo_draw_alpha_rgb16; + in_banshee_format = in_width * 2 | VOODOO_BLT_FORMAT_16; + in_bytepp = 2; + break; + case IMGFMT_BGR|24: + // FIXME: !!!! + //video_out_tdfxfb.draw_frame = draw_frame_BGR24; + video_out_tdfxfb.draw_frame = draw_frame; // draw_frame_BGR24; + //*our_out_buffer = vidpage1; + + in_banshee_format = in_width * 3 | VOODOO_BLT_FORMAT_24; + in_bytepp = 3; + break; + } + + + // Clear pages 1,2,3 + // leave page 0, that belongs to X. + // So does part of 1. Oops. + memset(vidpage0, 0x00, screenwidth * screenheight * screendepth); + memset(vidpage1, 0x00, screenwidth * screenheight * screendepth); + memset(in_page0, 0x00, in_width * in_height * in_bytepp); + + // Show page 0 (unblanked) + reg_IO->vidDesktopStartAddr = vidpage0offset; + //banshee_make_room(1); + //tdfx_outl(VIDDESKSTART, vidpage1offset); + + /* fd is deliberately not closed - if it were, mmaps might be released??? */ + + atexit(restore); + + printf("(display) 3dfx initialized %p/%p\n",memBase0,memBase1); + return 0; +} + +static const vo_info_t* +get_info(void) +{ + return &vo_info; +} + +// ------------------------------------------------------------------- +// YV12 fork fine. but only on vcd, with ffmpeg codec for DivX don't given corect picture. + +static uint32_t +draw_frame_YV12(uint8_t *src[]) +{ + //printf("vo_3dfx->draw_frame_YV12\n"); + return 0; +} + +static uint32_t +draw_slice_YV12(uint8_t *image[], int stride[], int w,int h,int x,int y) +{ + dump_yuv_planar((uint32_t *)image[0], (uint32_t *)image[1], + (uint32_t *)image[2], in_page0_offset, x, y, w, h); + return 0; +} + +static void +flip_page_YV12(void) +{ + S2S_BLT(2 | 1 << 8 | 0xcc << 24, // 2 | 1<<8 | 0xcc<<24, + vidpage0offset, vid_banshee_xy, + vid_banshee_format, vid_banshee_size, + in_page0_offset, 0, + in_banshee_format, in_banshee_size); +} + +static void draw_alpha_YV12(int x0, int y0, int w, int h, unsigned char *src, + unsigned char *srca, int stride) +{ + unsigned char *dst = (void *)in_page0 + (in_width * y0 + x0) * 2; // 2 <= bpp + uint32_t dstride = in_width * 2; // 2 <= bpp + + //printf("draw_alpha: x0,y0 = %d,%d; w,h = %d,%d;\n", x0, y0, w, h); + //(*draw_alpha_p)(w, h, src, srca, stride, dst, dstride); + vo_draw_alpha_yuy2(w, h, src, srca, stride, dst, dstride); +} + + +static void draw_osd_YV12(void) +{ + vo_draw_text(in_width, in_height, draw_alpha_YV12); +} + + +// ------------------------------------------------------------------- +// YUYV & BGR16 support + +static uint32_t +draw_frame_YUY2_BGR16(uint8_t *src[]) +{ +#if VO_3DFX_METHOD == 1 + memcpy(in_page0, src[0], in_width * in_height * in_bytepp); +#endif +#if VO_3DFX_METHOD == 2 + // blt to offscreen page. + S2S_BLT(2 | 1 << 8 | 0xcc << 24, // 2 | 1<<8 | 0xcc<<24, + vidpage1offset, vid_banshee_xy, + vid_banshee_format, vid_banshee_size, + in_page0_offset, 0, + in_banshee_format, in_banshee_size); + banshee_wait_idle(); +#endif + return 0; +} + +static uint32_t +draw_slice_YUY2_BGR16(uint8_t *image[], int stride[], int w,int h,int x,int y) +{ + return 0; +} + +static void +flip_page_YUY2_BGR16(void) +{ +#if VO_3DFX_METHOD == 1 + S2S_BLT(2 | 1 << 8 | 0xcc << 24, // 2 | 1<<8 | 0xcc<<24, + vidpage0offset, vid_banshee_xy, + vid_banshee_format, vid_banshee_size, + in_page0_offset, 0, + in_banshee_format, in_banshee_size); + banshee_wait_idle(); +#endif +#if VO_3DFX_METHOD == 2 + uint32_t o; + void *p; + + // flip screen pages. + o = vidpage0offset; vidpage0offset = vidpage1offset; vidpage1offset = o; + p = vidpage0; vidpage0 = vidpage1; vidpage1 = p; + + reg_IO->vidDesktopStartAddr = vidpage0offset; +#endif +} + +static void draw_alpha_YUY2_BGR16(int x0, int y0, int w, int h, unsigned char *src, + unsigned char *srca, int stride) +{ +#if VO_3DFX_METHOD == 1 + unsigned char *dst = (void *)in_page0 + (in_width * y0 + x0) * 2; // 2 <= bpp + uint32_t dstride = in_width * 2; // 2 <= bpp +#endif +#if VO_3DFX_METHOD == 2 + unsigned char *dst = (void *)vidpage1 + (screenwidth * (vidy+y0) + vidx+x0) * 2; // 2 <= bpp + uint32_t dstride = screenwidth * 2; // 2 <= bpp +#endif + //printf("draw_alpha: x0,y0 = %d,%d; w,h = %d,%d;\n", x0, y0, w, h); + (*draw_alpha_p)(w, h, src, srca, stride, dst, dstride); +} + +static void draw_osd_YUY2_BGR16(void) +{ +#if VO_3DFX_METHOD == 1 + vo_draw_text(in_width, in_height, draw_alpha_YUY2_BGR16); +#endif +#if VO_3DFX_METHOD == 2 + //vo_draw_text(screenwidth, screenheight, draw_alpha_YUY2_BGR16); + //vo_draw_text(vidwidth, vidheight, draw_alpha_YUY2_BGR16); + vo_draw_text(vidwidth, vidheight, draw_alpha_YUY2_BGR16); +#endif +} + +// ------------------------------------------------------------------- + +static uint32_t +draw_frame(uint8_t *src[]) +{ + /* dummy */ + return 0; +} + +static uint32_t +draw_slice(uint8_t *image[], int stride[], int w,int h,int x,int y) +{ + /* dummy */ + return 0; +} + +static void +flip_page(void) +{ + /* dummy */ +} + +#if 0 +static void +flip_page_all(void) +{ + S2S_BLT(2 | 1 << 8 | 0xcc << 24, // 2 | 1<<8 | 0xcc<<24, + vidpage0offset, vid_banshee_xy, + vid_banshee_format, vid_banshee_size, + in_page0_offset, 0, + in_banshee_format, in_banshee_size); +} + + +static void +flip_page_YUY2_2(void) +{ + void *p; + uint32_t o; + + /* flip screen buffer */ + p = vidpage0; vidpage0 = vidpage1; vidpage1 = p; + o = vidpage0offset; vidpage0offset = vidpage1offset; vidpage1offset = o; + reg_IO->vidDesktopStartAddr = vidpage0offset; + + + //banshee_make_room(1); + //tdfx_outl(VIDDESKSTART, vidpage0offset); + //banshee_wait_idle(); + +#if 0 + S2S_BLT(2 | 1 << 8 | 0xCC << 24, + vidpage0offset, vid_banshee_xy, + vid_banshee_format, vid_banshee_size, + in_page1_offset, 0, + in_banshee_format, in_banshee_size); + banshee_wait_idle(); +#endif +#if 0 + S2S_BLT(2 | 1 << 8 | 0xCC << 24, + vidpage0offset, vid_banshee_xy, + vid_banshee_format, vid_banshee_size, + vidpage1offset, vid_banshee_xy, + vid_banshee_format, vid_banshee_size); + + banshee_wait_idle(); +#endif +#if 0 + banshee_make_room(3+9); + + tdfx_outl(COMMANDEXTRA_2D, 4); + tdfx_outl(CLIP0MIN, 0); + tdfx_outl(CLIP0MAX, 0xffffffff); + tdfx_outl(SRCBASE, page_0_offset); + tdfx_outl(SRCXY, 0); + tdfx_outl(SRCFORMAT, in_banshee_format); + tdfx_outl(SRCSIZE, in_banshee_size); + + tdfx_outl(DSTBASE, vidpage0offset); + tdfx_outl(DSTXY, vid_banshee_xy); + tdfx_outl(DSTFORMAT, vid_banshee_format); + tdfx_outl(DSTSIZE, vid_banshee_size); + + tdfx_outl(COMMAND_2D, 2 | 1<<8 | 0xcc << 24); + banshee_wait_idle(); +#endif +} +#endif + + +static uint32_t +query_format(uint32_t format) +{ + switch(format){ + case IMGFMT_YV12: + return 4|2; // 4|2; + case IMGFMT_YUY2: + if (verbose) printf("query_format: IMGFMT_YUY2\n"); + return 0; //4|2; + case IMGFMT_RGB|24: + if (verbose) printf("query_format: IMGFMT_RGB|24\n"); + return 0; + case IMGFMT_BGR|24: + if (verbose) printf("query_format: IMGFMT_BGR|24\n"); + return 0; + case IMGFMT_BGR|16: + return 4|2; // 4|1; /* osd + ????? */ + } + return 0; +} + +static void +uninit(void) +{ +} + + +static void check_events(void) +{ +} + +static void draw_alpha(int x0, int y0, int w, int h, unsigned char *src, + unsigned char *srca, int stride) +{ + unsigned char *dst = (void *)vidpage1 + (in_width * y0 + x0) * 2; // 2 <= bpp + uint32_t dstride = in_width * 2; // 2 <= bpp + + //printf("draw_alpha: x0,y0 = %d,%d; w,h = %d,%d;\n", x0, y0, w, h); + //(*draw_alpha_p)(w, h, src, srca, stride, dst, dstride); + vo_draw_alpha_rgb16(w, h, src, srca, stride, dst, dstride); +} + +static void draw_osd(void) +{ +#if 1 + vo_draw_text(vidwidth, vidheight, draw_alpha); +#else + zz_draw_text(in_width, in_height, draw_alpha); + S2S_BLT(2 | 1 << 8 | 0xCC << 24, + in_page1_offset, in_banshee_xy, + in_banshee_format, in_banshee_size, + in_pageT_offset, 0, + in_banshee_format, in_banshee_size); + banshee_wait_idle(); +#endif +} + +