libvo/vo_tdfx_vid.c

   1 /*
   2  *  vo_tdfx_vid.c
   3  *
   4  *      Copyright (C) Alban Bedel - 03/2003
   5  *
   6  *  This file is part of MPlayer, a free movie player.
   7  *
   8  *  MPlayer is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2, or (at your option)
  11  *  any later version.
  12  *
  13  *  MPlayer is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with GNU Make; see the file COPYING.  If not, write to
  20  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  21  *
  22  */
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <errno.h>
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <fcntl.h>
  31 #include <unistd.h>
  32 #include <sys/ioctl.h>
  33 #include <sys/mman.h>
  34 #include "config.h"
  35 #include "video_out.h"
  36 #include "video_out_internal.h"
  37 #include "aspect.h"
  38 #include "mp_msg.h"
  39
  40 #include "fastmemcpy.h"
  41 #include "drivers/tdfx_vid.h"
  42
  43
  44 static vo_info_t info =
  45 {
  46         "tdfx vid",
  47         "tdfx_vid",
  48         "Albeu",
  49         ""
  50 };
  51
  52 //#define VERBOSE
  53
  54 LIBVO_EXTERN(tdfx_vid)
  55
  56 static tdfx_vid_config_t tdfx_cfg;
  57
  58 static unsigned char* agp_mem = NULL;
  59 static int tdfx_fd = -1;
  60
  61 static uint32_t img_fmt; // The real input format
  62 static uint32_t src_width, src_height, src_fmt, src_bpp, src_stride;
  63 static uint32_t dst_width, dst_height, dst_fmt, dst_bpp, dst_stride;
  64
  65 static uint32_t tdfx_page;
  66 static uint32_t front_buffer;
  67 static uint32_t back_buffer;
  68 static uint8_t num_buffer = 3;
  69 static uint32_t buffer_size; // Max size
  70 static uint8_t current_buffer = 0;
  71 static uint8_t current_ip_buf = 0;
  72 static uint32_t buffer_stride[3];
  73
  74 static int use_overlay = 1;
  75 static tdfx_vid_overlay_t tdfx_ov;
  76
  77 // FIXME
  78 static void clear_screen(void) {
  79   tdfx_vid_agp_move_t mov;
  80
  81   memset(agp_mem,0,tdfx_cfg.screen_width*dst_bpp*tdfx_cfg.screen_height);
  82
  83   mov.move2 = TDFX_VID_MOVE_2_PACKED;
  84   mov.width = tdfx_cfg.screen_width*dst_bpp;
  85   mov.height = tdfx_cfg.screen_height;
  86   mov.src = 0;
  87   mov.src_stride = tdfx_cfg.screen_width*dst_bpp;
  88   mov.dst = front_buffer;
  89   mov.dst_stride = tdfx_cfg.screen_stride;
  90
  91   printf("Move %d(%d) x %d => %d \n", mov.width,mov.src_stride,mov.height,mov.dst_stride);
  92
  93   if(ioctl(tdfx_fd,TDFX_VID_AGP_MOVE,&mov))
  94     printf("tdfx_vid: AGP move failed to clear the screen\n");
  95
  96 }
  97
  98 static uint32_t draw_slice(uint8_t *image[], int stride[], int w,int h,int x,int y)
  99 {
 100   uint8_t* ptr[3];
 101
 102 #ifdef VERBOSE
 103   printf("Draw slices %d\n",current_buffer);
 104 #endif
 105   switch(img_fmt) {
 106   case IMGFMT_YUY2:
 107   case IMGFMT_UYVY:
 108   case IMGFMT_BGR8:
 109   case IMGFMT_BGR16:
 110   case IMGFMT_BGR24:
 111   case IMGFMT_BGR32:
 112     // copy :( to agp_mem
 113     // still faster than tdfxfb wich directly copy to the video mem :)
 114     mem2agpcpy_pic(agp_mem + current_buffer * buffer_size +
 115                y*buffer_stride[0] + x * src_bpp,
 116                image[0],
 117                src_bpp*w,h,buffer_stride[0],stride[0]);
 118     return 0;
 119
 120   case IMGFMT_YV12:
 121   case IMGFMT_I420:
 122     // Copy to agp mem
 123     ptr[0] = agp_mem + current_buffer * buffer_size;
 124     mem2agpcpy_pic(ptr[0] + y * buffer_stride[0] + x,image[0],w,h,
 125                    buffer_stride[0],stride[0]);
 126     ptr[1] = ptr[0] + (src_height*src_width);
 127     mem2agpcpy_pic(ptr[1] + y/2 * buffer_stride[1] + x/2,image[1],w/2,h/2,
 128                    buffer_stride[1],stride[1]);
 129     ptr[2] = ptr[1] + (src_height*src_width/4);
 130     mem2agpcpy_pic(ptr[2] + y/2 * buffer_stride[2] + x/2,image[2],w/2,h/2,
 131                    buffer_stride[2],stride[2]);
 132     return 0;
 133   }
 134
 135   return 1;
 136 }
 137
 138 static void draw_osd(void)
 139 {
 140 }
 141
 142 static void
 143 flip_page(void)
 144 {
 145   tdfx_vid_blit_t blit;
 146   //return;
 147   // Scale convert
 148 #ifdef VERBOSE
 149   printf("Flip\n");
 150 #endif
 151   if(use_overlay) {
 152     // TDFX_VID_OVERLAY_ON does nothing if the overlay is alredy on
 153     if(!ioctl(tdfx_fd,TDFX_VID_OVERLAY_ON)) { // X11 killed the overlay :(
 154       if(ioctl(tdfx_fd,TDFX_VID_SET_OVERLAY,&tdfx_ov))
 155         mp_msg(MSGT_VO, MSGL_ERR, "tdfx_vid: set_overlay failed\n");
 156     }
 157     // These formats need conversion
 158     switch(src_fmt) {
 159     case IMGFMT_BGR8:
 160     case IMGFMT_BGR24:
 161     case IMGFMT_BGR32:
 162       memset(&blit,0,sizeof(tdfx_vid_blit_t));
 163       blit.src = back_buffer;
 164       blit.src_stride = src_stride;
 165       blit.src_x = 0;
 166       blit.src_y = 0;
 167       blit.src_w = src_width;
 168       blit.src_h = src_height;
 169       blit.src_format = src_fmt;
 170
 171       blit.dst = front_buffer;
 172       blit.dst_stride = dst_stride;
 173       blit.dst_x = 0;
 174       blit.dst_y = 0;
 175       blit.dst_w = src_width;
 176       blit.dst_h = src_height;
 177       blit.dst_format = IMGFMT_BGR16;
 178       if(ioctl(tdfx_fd,TDFX_VID_BLIT,&blit))
 179         printf("tdfx_vid: Blit failed\n");
 180     }
 181     return;
 182   }
 183   memset(&blit,0,sizeof(tdfx_vid_blit_t));
 184   blit.src = back_buffer;
 185   blit.src_stride = src_stride;
 186   blit.src_x = 0;
 187   blit.src_y = 0;
 188   blit.src_w = src_width;
 189   blit.src_h = src_height;
 190   blit.src_format = src_fmt;
 191
 192   blit.dst = front_buffer;
 193   blit.dst_stride = dst_stride;
 194   blit.dst_x = 0;
 195   blit.dst_y = 0;
 196   blit.dst_w = dst_width;
 197   blit.dst_h = dst_height;
 198   blit.dst_format = dst_fmt;
 199
 200   if(ioctl(tdfx_fd,TDFX_VID_BLIT,&blit))
 201     printf("tdfx_vid: Blit failed\n");
 202 }
 203
 204 static uint32_t
 205 draw_frame(uint8_t *src[])
 206 {
 207   int stride[] = { src_stride, 0, 0};
 208   return draw_slice(src,stride,src_width, src_height,0,0);
 209 }
 210
 211 static uint32_t
 212 query_format(uint32_t format)
 213 {
 214   switch(format) {
 215   case IMGFMT_BGR8:
 216     if(tdfx_cfg.screen_format == TDFX_VID_FORMAT_BGR8)
 217       return 3 | VFCAP_HWSCALE_UP | VFCAP_HWSCALE_DOWN | VFCAP_ACCEPT_STRIDE;
 218     return 0;
 219   case IMGFMT_YUY2:
 220   case IMGFMT_UYVY:
 221   case IMGFMT_BGR15:
 222   case IMGFMT_BGR16:
 223   case IMGFMT_BGR24:
 224   case IMGFMT_BGR32:
 225   case IMGFMT_YV12:
 226   case IMGFMT_I420:
 227     if(tdfx_cfg.screen_format == TDFX_VID_FORMAT_BGR8)
 228       return 0;
 229     return 3 | VFCAP_HWSCALE_UP | VFCAP_HWSCALE_DOWN | VFCAP_ACCEPT_STRIDE;
 230   }
 231   return 0;
 232 }
 233
 234 static uint32_t
 235 config(uint32_t width, uint32_t height, uint32_t d_width, uint32_t d_height, uint32_t fullscreen, char *title, uint32_t format)
 236 {
 237
 238   if(tdfx_fd < 0)
 239     return 1;
 240   // When we are run as sub vo we must follow the size gaven to us
 241   if(!(fullscreen & VOFLAG_XOVERLAY_SUB_VO)) {
 242     if(!vo_screenwidth)
 243       vo_screenwidth = tdfx_cfg.screen_width;
 244     if(!vo_screenheight)
 245       vo_screenheight = tdfx_cfg.screen_height;
 246
 247     aspect_save_orig(width,height);
 248     aspect_save_prescale(d_width,d_height);
 249     aspect_save_screenres(vo_screenwidth,vo_screenheight);
 250
 251     if(fullscreen&0x01) { /* -fs */
 252       aspect(&d_width,&d_height,A_ZOOM);
 253       vo_fs = VO_TRUE;
 254     } else {
 255       aspect(&d_width,&d_height,A_NOZOOM);
 256       vo_fs = VO_FALSE;
 257     }
 258   }
 259   src_width = width;
 260   src_height = height;
 261   buffer_size = 0;
 262   buffer_stride[0] = 0;
 263   src_fmt = 0;
 264   switch(format) {
 265   case IMGFMT_BGR8:
 266   case IMGFMT_BGR24:
 267   case IMGFMT_BGR32:
 268     if(use_overlay)
 269       printf("tdfx_vid: Non-native overlay format need conversion\n");
 270   case IMGFMT_BGR15:
 271   case IMGFMT_BGR16:
 272     src_bpp = ((format & 0x3F)+7)/8;
 273     break;
 274   case IMGFMT_YV12:
 275   case IMGFMT_I420:
 276     buffer_size = src_width * src_height * 3 / 2;
 277     buffer_stride[0] = ((src_width+1)/2)*2;
 278     buffer_stride[1] = buffer_stride[2] = buffer_stride[0]/2;
 279     src_fmt = TDFX_VID_FORMAT_YUY2;
 280   case IMGFMT_YUY2:
 281   case IMGFMT_UYVY:
 282     src_bpp = 2;
 283     break;
 284   default:
 285     printf("Unsupported input format 0x%x\n",format);
 286     return 1;
 287   }
 288
 289   img_fmt = format;
 290   src_stride = src_width*src_bpp;
 291   // The overlay need a 4 bytes aligned stride
 292   if(use_overlay)
 293     src_stride = ((src_stride+3)/4)*4;
 294   if(!src_fmt)
 295     src_fmt = format;
 296   if(!buffer_size)
 297     buffer_size = src_stride*src_height;
 298   if(!buffer_stride[0])
 299     buffer_stride[0] = src_stride;
 300
 301   dst_fmt = tdfx_cfg.screen_format;
 302   dst_bpp = ((dst_fmt & 0x3F)+7)/8;
 303   dst_width = d_width;
 304   dst_height = d_height;
 305   dst_stride = tdfx_cfg.screen_stride;
 306
 307   tdfx_page =  tdfx_cfg.screen_stride*tdfx_cfg.screen_height;
 308   front_buffer = tdfx_cfg.screen_start;
 309   back_buffer = front_buffer + tdfx_page;
 310
 311   while(use_overlay) {
 312     tdfx_vid_overlay_t ov;
 313     uint32_t ov_fmt = src_fmt, ov_stride = src_stride;
 314     // Align the buffer
 315     back_buffer = (((back_buffer+3)/4)*4);
 316     // With the overlay the front buffer is not on the screen
 317     // so we take the back buffer
 318     front_buffer = back_buffer;
 319     switch(src_fmt) {
 320     case IMGFMT_BGR8:
 321     case IMGFMT_BGR24:
 322     case IMGFMT_BGR32:
 323       back_buffer = front_buffer + 2*(src_stride*src_height);
 324       ov_stride = dst_stride = src_width<<1;
 325       ov_fmt = IMGFMT_BGR16;
 326       break;
 327     }
 328     ov.src[0] = front_buffer;
 329     ov.src[1] = front_buffer + (src_stride*src_height);
 330     ov.src_width = src_width;
 331     ov.src_height = src_height;
 332     ov.src_stride = ov_stride;
 333     ov.format = ov_fmt;
 334     ov.dst_width = dst_width;
 335     ov.dst_height = dst_height;
 336     ov.dst_x = vo_dx;
 337     ov.dst_y = vo_dy;
 338     ov.use_colorkey = 0;
 339
 340     if(ioctl(tdfx_fd,TDFX_VID_SET_OVERLAY,&ov)) {
 341       printf("tdfxvid: Overlay setup failed\n");
 342       use_overlay = 0;
 343       break;
 344     }
 345     tdfx_ov = ov;
 346     if(use_overlay == 1) {
 347       if(ioctl(tdfx_fd,TDFX_VID_OVERLAY_ON)) {
 348         printf("tdfx_vid: Overlay on failed\n");
 349         use_overlay = 0;
 350         break;
 351       }
 352       use_overlay++;
 353     }
 354
 355     printf("tdfx_vid: Overlay ready : %d(%d) x %d @ %d => %d(%d) x %d @ %d\n",
 356            src_width,src_stride,src_height,src_bpp,
 357            dst_width,dst_stride,dst_height,dst_bpp);
 358     break;
 359   }
 360
 361   if(!use_overlay)
 362     printf("tdfx_vid : Texture blit ready %d(%d) x %d @ %d => %d(%d) x %d @ %d\n",
 363            src_width,src_stride,src_height,src_bpp,
 364            dst_width,dst_stride,dst_height,dst_bpp);
 365
 366   return 0;
 367 }
 368
 369 static void
 370 uninit(void)
 371 {
 372   if(use_overlay == 2) {
 373     if(ioctl(tdfx_fd,TDFX_VID_OVERLAY_OFF))
 374       printf("tdfx_vid: Overlay off failed\n");
 375     use_overlay--;
 376   }
 377   close(tdfx_fd);
 378   tdfx_fd = -1;
 379 }
 380
 381
 382 static void check_events(void)
 383 {
 384 }
 385
 386 static uint32_t preinit(const char *arg)
 387 {
 388
 389   tdfx_fd = open(arg ? arg : "/dev/tdfx_vid", O_RDWR);
 390   if(tdfx_fd < 0) {
 391     printf("tdfx_vid: Can't open %s: %s\n",arg ? arg : "/dev/tdfx_vid",
 392            strerror(errno));
 393     return 1;
 394   }
 395
 396   if(ioctl(tdfx_fd,TDFX_VID_GET_CONFIG,&tdfx_cfg)) {
 397     printf("tdfx_vid: Can't get current cfg: %s\n",strerror(errno));
 398     return 1;
 399   }
 400
 401   printf("tdfx_vid version %d\n"
 402          "  Ram: %d\n"
 403          "  Screen: %d x %d\n"
 404          "  Format: %c%c%c%d\n",
 405          tdfx_cfg.version,
 406          tdfx_cfg.ram_size,
 407          tdfx_cfg.screen_width, tdfx_cfg.screen_height,
 408          tdfx_cfg.screen_format>>24,(tdfx_cfg.screen_format>>16)&0xFF,
 409          (tdfx_cfg.screen_format>>8)&0xFF,tdfx_cfg.screen_format&0xFF);
 410
 411   // For now just allocate more than i ever need
 412   agp_mem = mmap( NULL, 1024*768*4, PROT_READ | PROT_WRITE, MAP_SHARED,
 413                   tdfx_fd, 0);
 414
 415   if(agp_mem == MAP_FAILED) {
 416     printf("tdfx_vid: Memmap failed !!!!!\n");
 417     return 1;
 418   }
 419
 420   memset(agp_mem,0,1024*768*4);
 421
 422   return 0;
 423 }
 424
 425 static uint32_t get_image(mp_image_t *mpi) {
 426   int buf = 0;
 427
 428 #ifdef VERBOSE
 429   printf("Get image %d\n",buf);
 430 #endif
 431
 432   // Currently read are too slow bcs we read from the
 433   // agp aperture and not the memory directly
 434   //if(mpi->flags&MP_IMGFLAG_READABLE) return VO_FALSE;
 435
 436   if(mpi->flags&MP_IMGFLAG_READABLE &&
 437      (mpi->type==MP_IMGTYPE_IPB || mpi->type==MP_IMGTYPE_IP)){
 438     // reference (I/P) frame of IP or IPB:
 439     if(num_buffer<2) return VO_FALSE; // not enough
 440     current_ip_buf^=1;
 441     // for IPB with 2 buffers we can DR only one of the 2 P frames:
 442     if(mpi->type==MP_IMGTYPE_IPB && num_buffer<3 && current_ip_buf) return VO_FALSE;
 443     buf=current_ip_buf;
 444     if(mpi->type==MP_IMGTYPE_IPB) ++buf; // preserve space for B
 445   }
 446
 447   switch(mpi->imgfmt) {
 448   case IMGFMT_YUY2:
 449   case IMGFMT_UYVY:
 450   case IMGFMT_BGR8:
 451   case IMGFMT_BGR15:
 452   case IMGFMT_BGR16:
 453   case IMGFMT_BGR24:
 454   case IMGFMT_BGR32:
 455     mpi->planes[0] = agp_mem + buf * buffer_size;
 456     mpi->stride[0] = src_stride;
 457     break;
 458   case IMGFMT_YV12:
 459   case IMGFMT_I420:
 460     mpi->planes[0] = agp_mem + buf * buffer_size;
 461     mpi->stride[0] = mpi->width;
 462     mpi->planes[1] = mpi->planes[0] + mpi->stride[0]*mpi->height;
 463     mpi->stride[1] = mpi->chroma_width;
 464     mpi->planes[2] = mpi->planes[1] + mpi->stride[1]*mpi->chroma_height;
 465     mpi->stride[2] = mpi->chroma_width;
 466     break;
 467   default:
 468     printf("Get image todo\n");
 469     return VO_FALSE;
 470   }
 471   mpi->flags |= MP_IMGFLAG_DIRECT;
 472   mpi->priv = (void*)buf;
 473
 474   return VO_TRUE;
 475 }
 476
 477 static uint32_t start_slice(mp_image_t *mpi){
 478   int buf = 0;
 479
 480 #ifdef VERBOSE
 481   printf("Start slices %d\n",buf);
 482 #endif
 483
 484   if(mpi->flags & MP_IMGFLAG_DIRECT)
 485     buf = (int)mpi->priv;
 486   current_buffer = buf;
 487
 488   return VO_TRUE;
 489 }
 490
 491 static uint32_t draw_image(mp_image_t *mpi){
 492   int buf = 0;
 493   tdfx_vid_agp_move_t mov;
 494   tdfx_vid_yuv_t yuv;
 495   int p;
 496   uint8_t* planes[3];
 497   int stride[3];
 498
 499 #ifdef VERBOSE
 500   printf("Draw image %d\n",buf);
 501 #endif
 502
 503   if(mpi->flags & MP_IMGFLAG_DIRECT)
 504     buf = (int)mpi->priv;
 505
 506   switch(mpi->imgfmt) {
 507   case IMGFMT_YUY2:
 508   case IMGFMT_UYVY:
 509   case IMGFMT_BGR8:
 510   case IMGFMT_BGR15:
 511   case IMGFMT_BGR16:
 512   case IMGFMT_BGR24:
 513   case IMGFMT_BGR32:
 514     if(!(mpi->flags&(MP_IMGFLAG_DIRECT|MP_IMGFLAG_DRAW_CALLBACK))) {
 515       // copy to agp_mem
 516 #ifdef VERBOSE
 517       printf("Memcpy\n");
 518 #endif
 519       planes[0] = agp_mem + buf * buffer_size;
 520       mem2agpcpy_pic(planes[0],mpi->planes[0],src_bpp*mpi->width,mpi->height,
 521                      buffer_stride[0],mpi->stride[0]);
 522     } else
 523       planes[0] = agp_mem + buf * buffer_size;
 524
 525     mov.move2 = TDFX_VID_MOVE_2_PACKED;
 526     mov.width = mpi->width*((mpi->bpp+7)/8);
 527     mov.height = mpi->height;
 528     mov.src = planes[0] - agp_mem;
 529     mov.src_stride = buffer_stride[0];
 530
 531     mov.dst = back_buffer;
 532     mov.dst_stride = src_stride;
 533
 534     if(ioctl(tdfx_fd,TDFX_VID_AGP_MOVE,&mov))
 535       printf("tdfx_vid: AGP move failed\n");
 536     break;
 537
 538   case IMGFMT_YV12:
 539   case IMGFMT_I420:
 540     if(!(mpi->flags&(MP_IMGFLAG_DIRECT|MP_IMGFLAG_DRAW_CALLBACK))) {
 541       // Copy to agp mem
 542 #ifdef VERBOSE
 543       printf("Memcpy\n");
 544 #endif
 545       planes[0] = agp_mem + buf * buffer_size;
 546       memcpy_pic(planes[0],mpi->planes[0],mpi->width,mpi->height,
 547                  buffer_stride[0],mpi->stride[0]);
 548       planes[1] = planes[0] + (mpi->height*mpi->stride[0]);
 549       memcpy_pic(planes[1],mpi->planes[1],mpi->chroma_width,mpi->chroma_height,
 550                  buffer_stride[1],mpi->stride[1]);
 551       planes[2] = planes[1] + (mpi->chroma_height*mpi->stride[1]);
 552       memcpy_pic(planes[2],mpi->planes[2],mpi->chroma_width,mpi->chroma_height,
 553                  buffer_stride[2],mpi->stride[2]);
 554     } else {
 555       planes[0] = agp_mem + buf * buffer_size;
 556       planes[1] = planes[0] + buffer_stride[0] * src_height;
 557       planes[2] = planes[1] + buffer_stride[1] * src_height/2;
 558     }
 559
 560     // Setup the yuv thing
 561     yuv.base = back_buffer;
 562     yuv.stride = src_stride;
 563     if(ioctl(tdfx_fd,TDFX_VID_SET_YUV,&yuv)) {
 564       printf("tdfx_vid: Set yuv failed\n");
 565       break;
 566     }
 567
 568
 569     // Now agp move that
 570     // Y
 571     mov.move2 = TDFX_VID_MOVE_2_YUV;
 572     mov.width = mpi->width;
 573     mov.height = mpi->height;
 574     mov.src = planes[0] - agp_mem;
 575     mov.src_stride =  buffer_stride[0];
 576     mov.dst = 0x0;
 577     mov.dst_stride = TDFX_VID_YUV_STRIDE;
 578
 579     if(ioctl(tdfx_fd,TDFX_VID_AGP_MOVE,&mov)) {
 580       printf("tdfx_vid: AGP move failed on Y plane\n");
 581       break;
 582     }
 583     //return 0;
 584     // U
 585     p = mpi->imgfmt == IMGFMT_YV12 ? 1 : 2;
 586     mov.width = mpi->chroma_width;
 587     mov.height = mpi->chroma_height;
 588     mov.src = planes[p] - agp_mem;
 589     mov.src_stride = buffer_stride[p];
 590     mov.dst += TDFX_VID_YUV_PLANE_SIZE;
 591     if(ioctl(tdfx_fd,TDFX_VID_AGP_MOVE,&mov)) {
 592       printf("tdfx_vid: AGP move failed on U plane\n");
 593       break;
 594     }
 595     // V
 596     p = mpi->imgfmt == IMGFMT_YV12 ? 2 : 1;
 597     mov.src = planes[p] - agp_mem;
 598     mov.src_stride = buffer_stride[p];
 599     mov.dst += TDFX_VID_YUV_PLANE_SIZE;
 600     if(ioctl(tdfx_fd,TDFX_VID_AGP_MOVE,&mov)) {
 601       printf("tdfx_vid: AGP move failed on U plane\n");
 602       break;
 603     }
 604     break;
 605   default:
 606     printf("What's that for a format 0x%x\n",mpi->imgfmt);
 607     return VO_TRUE;
 608   }
 609
 610   return VO_TRUE;
 611 }
 612
 613 static uint32_t fullscreen(void) {
 614   vo_fs ^= 1;
 615   aspect(&dst_width,&dst_height,vo_fs ? A_ZOOM : A_NOZOOM);
 616   // This does not work :((
 617   //clear_screen();
 618   return VO_TRUE;
 619 }
 620
 621 static uint32_t set_window(mp_win_t* w) {
 622   if(!use_overlay) return VO_FALSE;
 623
 624   tdfx_ov.dst_x = w->x;
 625   tdfx_ov.dst_y = w->y;
 626   tdfx_ov.dst_width = w->w;
 627   tdfx_ov.dst_height = w->h;
 628
 629   if(ioctl(tdfx_fd,TDFX_VID_SET_OVERLAY,&tdfx_ov))
 630     mp_msg(MSGT_VO, MSGL_V, "tdfx_vid: set window failed\n");
 631
 632   return VO_TRUE;
 633 }
 634
 635 static uint32_t set_colorkey(mp_colorkey_t* colork) {
 636   if(!use_overlay) return VO_FALSE;
 637
 638   tdfx_ov.colorkey[0] = tdfx_ov.colorkey[1] = colork->x11;
 639   tdfx_ov.use_colorkey = 1;
 640   tdfx_ov.invert_colorkey = 0;
 641
 642   if(ioctl(tdfx_fd,TDFX_VID_SET_OVERLAY,&tdfx_ov))
 643     mp_msg(MSGT_VO, MSGL_V, "tdfx_vid: set colorkey failed\n");
 644
 645   return VO_TRUE;
 646 }
 647
 648 static uint32_t control(uint32_t request, void *data, ...)
 649 {
 650   switch (request) {
 651   case VOCTRL_QUERY_FORMAT:
 652     return query_format(*((uint32_t*)data));
 653   case VOCTRL_GET_IMAGE:
 654     return get_image(data);
 655   case VOCTRL_DRAW_IMAGE:
 656     return draw_image(data);
 657   case VOCTRL_START_SLICE:
 658     return start_slice(data);
 659   case VOCTRL_FULLSCREEN:
 660     return fullscreen();
 661   case VOCTRL_XOVERLAY_SUPPORT:
 662     return VO_TRUE;
 663   case VOCTRL_XOVERLAY_SET_COLORKEY:
 664     return set_colorkey(data);
 665   case VOCTRL_XOVERLAY_SET_WIN:
 666     return set_window(data);
 667   }
 668   return VO_NOTIMPL;
 669 }
 670