libvo/vo_dga.c

   1 /*
   2  *
   3  * X11 DGA Interface
   4  *
   5  * Copyright ( C ) 2001, Andreas Ackermann. All Rights Reserved.
   6  *
   7  * <acki@acki-netz.de>
   8  *
   9  * Sourceforge username: acki2
  10  *
  11  */
  12
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <errno.h>
  17
  18 #include "config.h"
  19 #include "video_out.h"
  20 #include "video_out_internal.h"
  21 #include "aspect.h"
  22 #include "x11_common.h"
  23 #include "fastmemcpy.h"
  24 #include "mp_msg.h"
  25
  26 #include <X11/Xlib.h>
  27 #include <X11/extensions/xf86dga.h>
  28
  29 #ifdef HAVE_XF86VM
  30 #include <X11/extensions/xf86vmode.h>
  31 #endif
  32
  33 static const vo_info_t info = {
  34 #ifdef HAVE_DGA2
  35     "DGA ( Direct Graphic Access V2.0 )",
  36 #else
  37 #ifdef HAVE_XF86VM
  38     "DGA ( Direct Graphic Access V1.0+XF86VidModeExt. )",
  39 #else
  40     "DGA ( Direct Graphic Access V1.0 )",
  41 #endif
  42 #endif
  43     "dga",
  44     "Andreas Ackermann <acki@acki-netz.de>",
  45     ""
  46 };
  47
  48 const LIBVO_EXTERN(dga)
  49 //------------------------------------------------------------------
  50 //#define BITSPP (vo_dga_modes[vo_dga_active_mode].vdm_bitspp)
  51 //#define BYTESPP (vo_dga_modes[vo_dga_active_mode].vdm_bytespp)
  52 #define VO_DGA_INVALID_RES 100000
  53 #define HW_MODE (vo_dga_modes[vo_dga_hw_mode])
  54 #define SRC_MODE (vo_dga_modes[vo_dga_src_mode])
  55 struct vd_modes
  56 {
  57     int vdm_mplayer_depth;
  58     int vdm_supported;
  59     int vdm_depth;
  60     int vdm_bitspp;
  61     int vdm_bytespp;
  62     int vdm_rmask;
  63     int vdm_gmask;
  64     int vdm_bmask;
  65     int vdm_hw_mode;
  66 };
  67
  68 //------------------------------------------------------------------
  69
  70 static struct vd_modes vo_dga_modes[] = {
  71     // these entries describe HW modes
  72     // however, we use the same entries to tell mplayer what we support
  73     // so the last two values describe, which HW mode to use and which conversion
  74     // function to use for a mode that is not supported by HW
  75
  76     {0, 0, 0, 0, 0, 0, 0, 0, 0,},
  77     {15, 0, 15, 16, 2, 0x7c00, 0x03e0, 0x001f, 2,},
  78     {16, 0, 16, 16, 2, 0xf800, 0x07e0, 0x001f, 2,},
  79     {24, 0, 24, 24, 3, 0xff0000, 0x00ff00, 0x0000ff, 4},
  80     {32, 0, 24, 32, 4, 0x00ff0000, 0x0000ff00, 0x000000ff, 4}
  81 };
  82
  83 static int vo_dga_mode_num =
  84     sizeof(vo_dga_modes) / sizeof(struct vd_modes);
  85
  86 // enable a HW mode (by description)
  87 static int vd_EnableMode(int depth, int bitspp,
  88                          int rmask, int gmask, int bmask)
  89 {
  90     int i;
  91
  92     for (i = 1; i < vo_dga_mode_num; i++)
  93     {
  94         if (vo_dga_modes[i].vdm_depth == depth &&
  95             vo_dga_modes[i].vdm_bitspp == bitspp &&
  96             vo_dga_modes[i].vdm_rmask == rmask &&
  97             vo_dga_modes[i].vdm_gmask == gmask &&
  98             vo_dga_modes[i].vdm_bmask == bmask)
  99         {
 100             vo_dga_modes[i].vdm_supported = 1;
 101             vo_dga_modes[i].vdm_hw_mode = i;
 102             return i;
 103         }
 104     }
 105     return 0;
 106 }
 107
 108 static int vd_ModeEqual(int depth, int bitspp,
 109                         int rmask, int gmask, int bmask, int index)
 110 {
 111     return ((vo_dga_modes[index].vdm_depth == depth &&
 112              vo_dga_modes[index].vdm_bitspp == bitspp &&
 113              vo_dga_modes[index].vdm_rmask == rmask &&
 114              vo_dga_modes[index].vdm_gmask == gmask &&
 115              vo_dga_modes[index].vdm_bmask == bmask) ? 1 : 0);
 116 }
 117
 118
 119 // enable a HW mode (mplayer_depth decides which)
 120 static int vd_ValidateMode(int mplayer_depth)
 121 {
 122     int i;
 123
 124     if (mplayer_depth == 0)
 125         return 0;
 126     for (i = 1; i < vo_dga_mode_num; i++)
 127     {
 128         if (vo_dga_modes[i].vdm_mplayer_depth == mplayer_depth)
 129         {
 130             vo_dga_modes[i].vdm_supported = 1;
 131             vo_dga_modes[i].vdm_hw_mode = i;
 132             return i;
 133         }
 134     }
 135     return 0;
 136 }
 137
 138 // do we support this mode? (not important whether native or conversion)
 139 static int vd_ModeValid(int mplayer_depth)
 140 {
 141     int i;
 142
 143     if (mplayer_depth == 0)
 144         return 0;
 145     for (i = 1; i < vo_dga_mode_num; i++)
 146     {
 147         if (vo_dga_modes[i].vdm_mplayer_depth == mplayer_depth &&
 148             vo_dga_modes[i].vdm_supported != 0)
 149         {
 150             return i;
 151         }
 152     }
 153     return 0;
 154 }
 155
 156 static char *vd_GetModeString(int index)
 157 {
 158
 159 #define VO_DGA_MAX_STRING_LEN 100
 160     static char stringbuf[VO_DGA_MAX_STRING_LEN];
 161
 162     stringbuf[VO_DGA_MAX_STRING_LEN - 1] = 0;
 163     snprintf(stringbuf, VO_DGA_MAX_STRING_LEN - 2,
 164              "depth=%d, bpp=%d, r=%06x, g=%06x, b=%06x, %s (-bpp %d)",
 165              vo_dga_modes[index].vdm_depth,
 166              vo_dga_modes[index].vdm_bitspp,
 167              vo_dga_modes[index].vdm_rmask,
 168              vo_dga_modes[index].vdm_gmask,
 169              vo_dga_modes[index].vdm_bmask,
 170              vo_dga_modes[index].
 171              vdm_supported ? "native" : "not supported",
 172              vo_dga_modes[index].vdm_mplayer_depth);
 173     return stringbuf;
 174 }
 175
 176 //-----------------------------------------------------------------
 177
 178 #if defined(HAVE_XF86VM) && !defined(HAVE_DGA2)
 179 static XF86VidModeModeInfo **vo_dga_vidmodes = NULL;
 180 #endif
 181
 182
 183 static int vo_dga_src_format;
 184 static int vo_dga_width;        // bytes per line in framebuffer
 185 static int vo_dga_vp_width;     // visible pixels per line in
 186
 187                                          // framebuffer
 188 static int vo_dga_vp_height;    // visible lines in framebuffer
 189 static int vo_dga_is_running = 0;
 190 static int vo_dga_src_width;    // width of video in pixels
 191 static int vo_dga_src_height;   // height of video in pixels
 192 static int vo_dga_src_offset = 0;       // offset in src
 193 static int vo_dga_vp_offset = 0;        // offset in dest
 194 static int vo_dga_bytes_per_line;       // bytes per line to copy
 195 static int vo_dga_vp_skip;      // dto. for dest
 196 static int vo_dga_lines;        // num of lines to copy
 197 static int vo_dga_hw_mode = 0;  // index in mode list that is actually
 198
 199                                          // used by framebuffer
 200 static int vo_dga_src_mode = 0; // index in mode list that is used by
 201
 202                                          // codec
 203 static int vo_dga_XServer_mode = 0;     // index in mode list for resolution
 204
 205 #ifdef HAVE_DGA2
 206 static XDGAMode *vo_modelines;
 207 static int vo_modecount;
 208 #endif
 209
 210 #define MAX_NR_VIDEO_BUFFERS 3
 211
 212 #define CURRENT_VIDEO_BUFFER \
 213         (vo_dga_video_buffer[vo_dga_current_video_buffer])
 214
 215 static int vo_dga_nr_video_buffers;     // Total number of frame buffers.
 216 static int vo_dga_current_video_buffer; // Buffer available for rendering.
 217
 218 static struct video_buffer
 219 {
 220     int y;
 221     uint8_t *data;
 222 } vo_dga_video_buffer[MAX_NR_VIDEO_BUFFERS];
 223
 224 /* saved src and dst dimensions for SwScaler */
 225 static unsigned int scale_srcW = 0,
 226     scale_dstW = 0, scale_srcH = 0, scale_dstH = 0;
 227
 228 //---------------------------------------------------------
 229
 230 static void draw_alpha(int x0, int y0, int w, int h, unsigned char *src,
 231                        unsigned char *srca, int stride)
 232 {
 233
 234     char *d;
 235     unsigned int offset;
 236     int buffer_stride;
 237
 238     offset = vo_dga_width * y0 + x0;
 239     buffer_stride = vo_dga_width;
 240     d = CURRENT_VIDEO_BUFFER.data + vo_dga_vp_offset;
 241
 242     switch (HW_MODE.vdm_mplayer_depth)
 243     {
 244
 245         case 32:
 246             vo_draw_alpha_rgb32(w, h, src, srca, stride, d + 4 * offset,
 247                                 4 * buffer_stride);
 248             break;
 249         case 24:
 250             vo_draw_alpha_rgb24(w, h, src, srca, stride, d + 3 * offset,
 251                                 3 * buffer_stride);
 252             break;
 253         case 15:
 254             vo_draw_alpha_rgb15(w, h, src, srca, stride, d + 2 * offset,
 255                                 2 * buffer_stride);
 256             break;
 257         case 16:
 258             vo_draw_alpha_rgb16(w, h, src, srca, stride, d + 2 * offset,
 259                                 2 * buffer_stride);
 260             break;
 261     }
 262 }
 263
 264
 265 //---------------------------------------------------------
 266
 267
 268
 269
 270 // quick & dirty - for debugging only
 271 #if 0
 272 static void fillblock(char *strt, int yoff, int lines, int val)
 273 {
 274     char *i;
 275
 276     for (i = strt + yoff * vo_dga_width * HW_MODE.vdm_bytespp;
 277          i < strt + (lines + yoff) * vo_dga_width * HW_MODE.vdm_bytespp;)
 278     {
 279         *i++ = val;
 280     }
 281 }
 282 #endif
 283
 284 //---------------------------------------------------------
 285
 286 static int draw_frame(uint8_t * src[])
 287 {
 288
 289     int numlines = vo_dga_lines;
 290
 291     char *s, *d;
 292
 293     s = *src;
 294     d = CURRENT_VIDEO_BUFFER.data + vo_dga_vp_offset;
 295
 296     mem2agpcpy_pic(d, s,
 297                    vo_dga_bytes_per_line,
 298                    numlines,
 299                    vo_dga_bytes_per_line + vo_dga_vp_skip,
 300                    vo_dga_bytes_per_line);
 301
 302     // DBG-COde
 303
 304 #if 0
 305     d = CURRENT_VIDEO_BUFFER.data + vo_dga_vp_offset;
 306     fillblock(d, 0, 10, 0x800000ff);
 307     fillblock(d, 10, 10, 0x8000ff00);
 308     fillblock(d, 20, 10, 0x80ff0000);
 309     fillblock(d, 30, 10, 0xff0000ff);
 310     fillblock(d, 40, 10, 0x800000ff);
 311     fillblock(d, 50, 10, 0x0f0000ff);
 312 #endif
 313     return 0;
 314 }
 315
 316 //---------------------------------------------------------
 317
 318 static void check_events(void)
 319 {
 320     vo_x11_check_events(mDisplay);
 321 }
 322
 323 //---------------------------------------------------------
 324
 325 #include "sub.h"
 326
 327 static void draw_osd(void)
 328 {
 329     vo_draw_text(vo_dga_src_width, vo_dga_src_height, draw_alpha);
 330 }
 331
 332 static void switch_video_buffers(void)
 333 {
 334     vo_dga_current_video_buffer =
 335         (vo_dga_current_video_buffer + 1) % vo_dga_nr_video_buffers;
 336 }
 337
 338 static void flip_page(void)
 339 {
 340     if (1 < vo_dga_nr_video_buffers)
 341     {
 342 #ifdef HAVE_DGA2
 343         XDGASetViewport(mDisplay, mScreen,
 344                         0, CURRENT_VIDEO_BUFFER.y, XDGAFlipRetrace);
 345 #else
 346         XF86DGASetViewPort(mDisplay, mScreen, 0, CURRENT_VIDEO_BUFFER.y);
 347 #endif
 348         switch_video_buffers();
 349     }
 350 }
 351
 352 //---------------------------------------------------------
 353
 354 static int draw_slice(uint8_t * src[], int stride[],
 355                            int w, int h, int x, int y)
 356 {
 357     return 0;
 358 };
 359
 360 //---------------------------------------------------------
 361
 362 static int query_format(uint32_t format)
 363 {
 364
 365     if ((format & IMGFMT_BGR_MASK) == IMGFMT_BGR &&
 366         vd_ModeValid(format & 0xff))
 367     {
 368         return VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW | VFCAP_OSD;
 369     }
 370
 371     return 0;
 372 }
 373
 374 //---------------------------------------------------------
 375
 376 static void uninit(void)
 377 {
 378
 379 #ifdef HAVE_DGA2
 380     XDGADevice *dgadevice;
 381 #endif
 382
 383     if (!vo_config_count)
 384         return;
 385
 386     if (vo_dga_is_running)
 387     {
 388         vo_dga_is_running = 0;
 389         mp_msg(MSGT_VO, MSGL_V, "vo_dga: in uninit\n");
 390         if (vo_grabpointer)
 391             XUngrabPointer(mDisplay, CurrentTime);
 392         XUngrabKeyboard(mDisplay, CurrentTime);
 393 #ifdef HAVE_DGA2
 394         XDGACloseFramebuffer(mDisplay, mScreen);
 395         dgadevice = XDGASetMode(mDisplay, mScreen, 0);
 396         if (dgadevice != NULL)
 397         {
 398             XFree(dgadevice);
 399         }
 400 #else
 401         XF86DGADirectVideo(mDisplay, mScreen, 0);
 402         // first disable DirectVideo and then switch mode back!
 403 #ifdef HAVE_XF86VM
 404         if (vo_dga_vidmodes != NULL)
 405         {
 406             int screen;
 407
 408             screen = XDefaultScreen(mDisplay);
 409             mp_msg(MSGT_VO, MSGL_V,
 410                    "vo_dga: VidModeExt: Switching back..\n");
 411             // seems some graphics adaptors need this more than once ...
 412             XF86VidModeSwitchToMode(mDisplay, screen, vo_dga_vidmodes[0]);
 413             XF86VidModeSwitchToMode(mDisplay, screen, vo_dga_vidmodes[0]);
 414             XF86VidModeSwitchToMode(mDisplay, screen, vo_dga_vidmodes[0]);
 415             XF86VidModeSwitchToMode(mDisplay, screen, vo_dga_vidmodes[0]);
 416             XFree(vo_dga_vidmodes);
 417         }
 418 #endif
 419 #endif
 420     }
 421     vo_x11_uninit();
 422 }
 423
 424
 425 //----------------------------------------------------------
 426 // TODO: check for larger maxy value
 427 // (useful for double buffering!!!)
 428
 429 static int check_res(int num, int x, int y, int bpp,
 430                      int new_x, int new_y, int new_vbi, int new_maxy,
 431                      int *old_x, int *old_y, int *old_vbi, int *old_maxy)
 432 {
 433
 434     mp_msg(MSGT_VO, MSGL_V,
 435            "vo_dga: (%3d) Trying %4d x %4d @ %3d Hz @ depth %2d ..", num,
 436            new_x, new_y, new_vbi, bpp);
 437     mp_msg(MSGT_VO, MSGL_V, "(old: %dx%d@%d).", *old_x, *old_y, *old_vbi);
 438     if ((new_x >= x) && (new_y >= y) && (
 439                                             // prefer a better resolution either in X or in Y
 440                                             // as long as the other dimension is at least the same
 441                                             //
 442                                             // hmm ... MAYBE it would be more clever to focus on the
 443                                             // x-resolution; I had 712x400 and 640x480 and the movie
 444                                             // was 640x360; 640x480 would be the 'right thing' here
 445                                             // but since 712x400 was queried first I got this one.
 446                                             // I think there should be a cmd-line switch to let the
 447                                             // user choose the mode he likes ...   (acki2)
 448                                             (((new_x < *old_x) &&
 449                                               !(new_y > *old_y)) ||
 450                                              ((new_y < *old_y) &&
 451                                               !(new_x > *old_x)))
 452                                             // but if we get an identical resolution choose
 453                                             // the one with the lower refreshrate (saves bandwidth !!!)
 454                                             // as long as it's above 50 Hz (acki2 on 30/3/2001)
 455                                             ||
 456                                             (((new_x == *old_x) &&
 457                                               (new_y == *old_y) &&
 458                                               ((new_vbi >= *old_vbi
 459                                                 && *old_vbi < 50)
 460                                                || (*old_vbi >= 50
 461                                                    && new_vbi < *old_vbi
 462                                                    && new_vbi >= 50))) ||
 463                                              // if everything is equal, then use the mode with the lower
 464                                              // stride
 465                                              ((new_x == *old_x) &&
 466                                               (new_y == *old_y) &&
 467                                               (new_vbi == *old_vbi) &&
 468                                               (new_maxy > *old_maxy)))))
 469     {
 470         *old_x = new_x;
 471         *old_y = new_y;
 472         *old_maxy = new_maxy;
 473         *old_vbi = new_vbi;
 474         mp_msg(MSGT_VO, MSGL_V, ".ok!!\n");
 475         return 1;
 476     } else
 477     {
 478         mp_msg(MSGT_VO, MSGL_V, ".no\n");
 479         return 0;
 480     }
 481 }
 482
 483
 484
 485 //---------------------------------------------------------
 486
 487 static void init_video_buffers(uint8_t * buffer_base,
 488                                int view_port_height,
 489                                int bytes_per_scanline,
 490                                int max_view_port_y,
 491                                int use_multiple_buffers)
 492 {
 493     int bytes_per_buffer = view_port_height * bytes_per_scanline;
 494     int i;
 495
 496     if (use_multiple_buffers)
 497         vo_dga_nr_video_buffers = max_view_port_y / view_port_height;
 498     else
 499         vo_dga_nr_video_buffers = 1;
 500
 501     if (vo_dga_nr_video_buffers > MAX_NR_VIDEO_BUFFERS)
 502         vo_dga_nr_video_buffers = MAX_NR_VIDEO_BUFFERS;
 503     if (vo_dga_nr_video_buffers <= 0)
 504         vo_dga_nr_video_buffers = 1;
 505
 506     vo_dga_current_video_buffer = 0;
 507
 508     for (i = 0; i < vo_dga_nr_video_buffers; i++)
 509     {
 510         vo_dga_video_buffer[i].y = i * view_port_height;
 511         vo_dga_video_buffer[i].data = buffer_base + i * bytes_per_buffer;
 512
 513         // Clear video buffer.
 514         memset(vo_dga_video_buffer[i].data, 0, bytes_per_buffer);
 515     }
 516 }
 517
 518 static int config(uint32_t width, uint32_t height,
 519                        uint32_t d_width, uint32_t d_height,
 520                        uint32_t flags, char *title, uint32_t format)
 521 {
 522
 523     int x_off, y_off;
 524     int wanted_width, wanted_height;
 525
 526     static unsigned char *vo_dga_base;
 527     static int prev_width, prev_height;
 528
 529 #ifdef HAVE_DGA2
 530     // needed to change DGA video mode
 531     int mX = VO_DGA_INVALID_RES, mY = VO_DGA_INVALID_RES, mVBI =
 532         100000, mMaxY = 0, i, j = 0;
 533     int dga_modenum;
 534     XDGAMode *modeline;
 535     XDGADevice *dgadevice;
 536 #else
 537 #ifdef HAVE_XF86VM
 538     unsigned int vm_event, vm_error;
 539     unsigned int vm_ver, vm_rev;
 540     int i, j = 0, have_vm = 0;
 541     int mX = VO_DGA_INVALID_RES, mY = VO_DGA_INVALID_RES, mVBI =
 542         100000, mMaxY = 0, dga_modenum;
 543 #endif
 544     int bank, ram;
 545 #endif
 546
 547     vo_dga_src_format = format;
 548
 549     wanted_width = d_width;
 550     wanted_height = d_height;
 551
 552     if (!wanted_height)
 553         wanted_height = height;
 554     if (!wanted_width)
 555         wanted_width = width;
 556
 557     if (!vo_dbpp)
 558     {
 559         if ((format & IMGFMT_BGR_MASK) == IMGFMT_BGR)
 560         {
 561             vo_dga_src_mode = vd_ModeValid(format & 0xff);
 562         }
 563     } else
 564     {
 565         vo_dga_src_mode = vd_ModeValid(vo_dbpp);
 566     }
 567     vo_dga_hw_mode = SRC_MODE.vdm_hw_mode;
 568
 569     if (!vo_dga_src_mode)
 570     {
 571         mp_msg(MSGT_VO, MSGL_ERR, "vo_dga: unsupported video format!\n");
 572         return 1;
 573     }
 574
 575     vo_dga_vp_width = vo_screenwidth;
 576     vo_dga_vp_height = vo_screenheight;
 577
 578     mp_msg(MSGT_VO, MSGL_V, "vo_dga: XServer res: %dx%d\n",
 579            vo_dga_vp_width, vo_dga_vp_height);
 580
 581 // choose a suitable mode ...
 582
 583 #ifdef HAVE_DGA2
 584 // Code to change the video mode added by Michael Graffam
 585 // mgraffam@idsi.net
 586
 587     mp_msg(MSGT_VO, MSGL_V, "vo_dga: vo_modelines=%p, vo_modecount=%d\n",
 588            vo_modelines, vo_modecount);
 589
 590     if (vo_modelines == NULL)
 591     {
 592         mp_msg(MSGT_VO, MSGL_ERR, "vo_dga: can't get modelines\n");
 593         return 1;
 594     }
 595
 596     mp_msg(MSGT_VO, MSGL_INFO,
 597            "vo_dga: DGA 2.0 available :-) Can switch resolution AND depth!\n");
 598     for (i = 0; i < vo_modecount; i++)
 599     {
 600         if (vd_ModeEqual(vo_modelines[i].depth,
 601                          vo_modelines[i].bitsPerPixel,
 602                          vo_modelines[i].redMask,
 603                          vo_modelines[i].greenMask,
 604                          vo_modelines[i].blueMask, vo_dga_hw_mode))
 605         {
 606
 607             mp_msg(MSGT_VO, MSGL_V, "maxy: %4d, depth: %2d, %4dx%4d, ",
 608                    vo_modelines[i].maxViewportY, vo_modelines[i].depth,
 609                    vo_modelines[i].imageWidth,
 610                    vo_modelines[i].imageHeight);
 611             if (check_res
 612                 (i, wanted_width, wanted_height, vo_modelines[i].depth,
 613                  vo_modelines[i].viewportWidth,
 614                  vo_modelines[i].viewportHeight,
 615                  (unsigned) vo_modelines[i].verticalRefresh,
 616                  vo_modelines[i].maxViewportY, &mX, &mY, &mVBI, &mMaxY))
 617                 j = i;
 618         }
 619     }
 620     mp_msg(MSGT_VO, MSGL_INFO,
 621            "vo_dga: Selected hardware mode %4d x %4d @ %3d Hz @ depth %2d, bitspp %2d.\n",
 622            mX, mY, mVBI, HW_MODE.vdm_depth, HW_MODE.vdm_bitspp);
 623     mp_msg(MSGT_VO, MSGL_INFO,
 624            "vo_dga: Video parameters by codec: %3d x %3d, depth %2d, bitspp %2d.\n",
 625            width, height, SRC_MODE.vdm_depth, SRC_MODE.vdm_bitspp);
 626     vo_dga_vp_width = mX;
 627     vo_dga_vp_height = mY;
 628
 629     if ((flags & VOFLAG_SWSCALE) || (flags & VOFLAG_FULLSCREEN))
 630     {                           /* -zoom or -fs */
 631         scale_dstW = (d_width + 7) & ~7;
 632         scale_dstH = d_height;
 633         scale_srcW = width;
 634         scale_srcH = height;
 635         aspect_save_screenres(mX, mY);
 636         aspect_save_orig(scale_srcW, scale_srcH);
 637         aspect_save_prescale(scale_dstW, scale_dstH);
 638         if (flags & VOFLAG_FULLSCREEN)       /* -fs */
 639             aspect(&scale_dstW, &scale_dstH, A_ZOOM);
 640         else if (flags & VOFLAG_SWSCALE)  /* -fs */
 641             aspect(&scale_dstW, &scale_dstH, A_NOZOOM);
 642         mp_msg(MSGT_VO, MSGL_INFO,
 643                "vo_dga: Aspect corrected size for SwScaler: %4d x %4d.\n",
 644                scale_dstW, scale_dstH);
 645         /* XXX this is a hack, but I'm lazy ;-) :: atmos */
 646         width = scale_dstW;
 647         height = scale_dstH;
 648     }
 649
 650     vo_dga_width = vo_modelines[j].bytesPerScanline / HW_MODE.vdm_bytespp;
 651     dga_modenum = vo_modelines[j].num;
 652     modeline = vo_modelines + j;
 653
 654 #else
 655
 656 #ifdef HAVE_XF86VM
 657
 658     mp_msg(MSGT_VO, MSGL_INFO,
 659            "vo_dga: DGA 1.0 compatibility code: Using XF86VidMode for mode switching!\n");
 660
 661     if (XF86VidModeQueryExtension(mDisplay, &vm_event, &vm_error))
 662     {
 663         XF86VidModeQueryVersion(mDisplay, &vm_ver, &vm_rev);
 664         mp_msg(MSGT_VO, MSGL_INFO,
 665                "vo_dga: XF86VidMode Extension v%i.%i\n", vm_ver, vm_rev);
 666         have_vm = 1;
 667     } else
 668     {
 669         mp_msg(MSGT_VO, MSGL_ERR,
 670                "vo_dga: XF86VidMode Extension not available.\n");
 671     }
 672
 673 #define GET_VREFRESH(dotclk, x, y)( (((dotclk)/(x))*1000)/(y) )
 674
 675     if (have_vm)
 676     {
 677         int modecount;
 678
 679         XF86VidModeGetAllModeLines(mDisplay, mScreen, &modecount,
 680                                    &vo_dga_vidmodes);
 681
 682         if (vo_dga_vidmodes != NULL)
 683         {
 684             for (i = 0; i < modecount; i++)
 685             {
 686                 if (check_res(i, wanted_width, wanted_height,
 687                               vo_dga_modes[vo_dga_hw_mode].vdm_depth,
 688                               vo_dga_vidmodes[i]->hdisplay,
 689                               vo_dga_vidmodes[i]->vdisplay,
 690                               GET_VREFRESH(vo_dga_vidmodes[i]->dotclock,
 691                                            vo_dga_vidmodes[i]->htotal,
 692                                            vo_dga_vidmodes[i]->vtotal),
 693                               0, &mX, &mY, &mVBI, &mMaxY))
 694                     j = i;
 695             }
 696
 697             mp_msg(MSGT_VO, MSGL_INFO,
 698                    "vo_dga: Selected video mode %4d x %4d @ %3d Hz @ depth %2d, bitspp %2d, video %3d x %3d.\n",
 699                    mX, mY, mVBI,
 700                    vo_dga_modes[vo_dga_hw_mode].vdm_depth,
 701                    vo_dga_modes[vo_dga_hw_mode].vdm_bitspp, width, height);
 702         } else
 703         {
 704             mp_msg(MSGT_VO, MSGL_INFO,
 705                    "vo_dga: XF86VidMode returned no screens - using current resolution.\n");
 706         }
 707         dga_modenum = j;
 708         vo_dga_vp_width = mX;
 709         vo_dga_vp_height = mY;
 710     }
 711
 712 #else
 713     mp_msg(MSGT_VO, MSGL_INFO,
 714            "vo_dga: Only have DGA 1.0 extension and no XF86VidMode :-(\n");
 715     mp_msg(MSGT_VO, MSGL_INFO,
 716            "        Thus, resolution switching is NOT possible.\n");
 717
 718 #endif
 719 #endif
 720
 721     vo_dga_src_width = width;
 722     vo_dga_src_height = height;
 723
 724     if (vo_dga_src_width > vo_dga_vp_width ||
 725         vo_dga_src_height > vo_dga_vp_height)
 726     {
 727         mp_msg(MSGT_VO, MSGL_ERR,
 728                "vo_dga: Sorry, video larger than viewport is not yet supported!\n");
 729         // ugly, do something nicer in the future ...
 730 #ifndef HAVE_DGA2
 731 #ifdef HAVE_XF86VM
 732         if (vo_dga_vidmodes)
 733         {
 734             XFree(vo_dga_vidmodes);
 735             vo_dga_vidmodes = NULL;
 736         }
 737 #endif
 738 #endif
 739         return 1;
 740     }
 741
 742     if (vo_dga_vp_width == VO_DGA_INVALID_RES)
 743     {
 744         mp_msg(MSGT_VO, MSGL_ERR,
 745                "vo_dga: Something is wrong with your DGA. There doesn't seem to be a\n"
 746                "         single suitable mode!\n"
 747                "         Please file a bug report (see DOCS/HTML/en/bugreports.html)\n");
 748 #ifndef HAVE_DGA2
 749 #ifdef HAVE_XF86VM
 750         if (vo_dga_vidmodes)
 751         {
 752             XFree(vo_dga_vidmodes);
 753             vo_dga_vidmodes = NULL;
 754         }
 755 #endif
 756 #endif
 757         return 1;
 758     }
 759 // now let's start the DGA thing
 760
 761     if (!vo_config_count || width != prev_width || height != prev_height)
 762     {
 763 #ifdef HAVE_DGA2
 764
 765         if (!XDGAOpenFramebuffer(mDisplay, mScreen))
 766         {
 767             mp_msg(MSGT_VO, MSGL_ERR,
 768                    "vo_dga: Framebuffer mapping failed!!!\n");
 769             return 1;
 770         }
 771
 772         dgadevice = XDGASetMode(mDisplay, mScreen, dga_modenum);
 773         XDGASync(mDisplay, mScreen);
 774
 775         vo_dga_base = dgadevice->data;
 776         XFree(dgadevice);
 777
 778         XDGASetViewport(mDisplay, mScreen, 0, 0, XDGAFlipRetrace);
 779
 780 #else
 781
 782 #ifdef HAVE_XF86VM
 783         if (have_vm)
 784         {
 785             XF86VidModeLockModeSwitch(mDisplay, mScreen, 0);
 786             // Two calls are needed to switch modes on my ATI Rage 128. Why?
 787             // for riva128 one call is enough!
 788             XF86VidModeSwitchToMode(mDisplay, mScreen,
 789                                     vo_dga_vidmodes[dga_modenum]);
 790             XF86VidModeSwitchToMode(mDisplay, mScreen,
 791                                     vo_dga_vidmodes[dga_modenum]);
 792         }
 793 #endif
 794
 795         XF86DGAGetViewPortSize(mDisplay, mScreen,
 796                                &vo_dga_vp_width, &vo_dga_vp_height);
 797
 798         XF86DGAGetVideo(mDisplay, mScreen,
 799                         (char **) &vo_dga_base, &vo_dga_width, &bank,
 800                         &ram);
 801
 802         XF86DGADirectVideo(mDisplay, mScreen,
 803                            XF86DGADirectGraphics | XF86DGADirectMouse |
 804                            XF86DGADirectKeyb);
 805
 806         XF86DGASetViewPort(mDisplay, mScreen, 0, 0);
 807
 808 #endif
 809     }
 810     // do some more checkings here ...
 811
 812     mp_msg(MSGT_VO, MSGL_V,
 813            "vo_dga: bytes/line: %d, screen res: %dx%d, depth: %d, base: %p, bpp: %d\n",
 814            vo_dga_width, vo_dga_vp_width, vo_dga_vp_height,
 815            HW_MODE.vdm_bytespp, vo_dga_base, HW_MODE.vdm_bitspp);
 816
 817     x_off = (vo_dga_vp_width - vo_dga_src_width) >> 1;
 818     y_off = (vo_dga_vp_height - vo_dga_src_height) >> 1;
 819
 820     vo_dga_bytes_per_line = vo_dga_src_width * HW_MODE.vdm_bytespp;
 821     vo_dga_lines = vo_dga_src_height;
 822
 823     vo_dga_src_offset = 0;
 824     vo_dga_vp_offset =
 825         (y_off * vo_dga_width + x_off) * HW_MODE.vdm_bytespp;
 826
 827     vo_dga_vp_skip = (vo_dga_width - vo_dga_src_width) * HW_MODE.vdm_bytespp;   // todo
 828
 829     mp_msg(MSGT_VO, MSGL_V, "vo_dga: vp_off=%d, vp_skip=%d, bpl=%d\n",
 830            vo_dga_vp_offset, vo_dga_vp_skip, vo_dga_bytes_per_line);
 831
 832
 833     XGrabKeyboard(mDisplay, DefaultRootWindow(mDisplay), True,
 834                   GrabModeAsync, GrabModeAsync, CurrentTime);
 835     if (vo_grabpointer)
 836         XGrabPointer(mDisplay, DefaultRootWindow(mDisplay), True,
 837                      ButtonPressMask, GrabModeAsync, GrabModeAsync,
 838                      None, None, CurrentTime);
 839
 840     if (!vo_config_count || width != prev_width || height != prev_height)
 841     {
 842         init_video_buffers(vo_dga_base,
 843                            vo_dga_vp_height,
 844                            vo_dga_width * HW_MODE.vdm_bytespp,
 845 #ifdef HAVE_DGA2
 846                            modeline->maxViewportY,
 847 #else
 848                            vo_dga_vp_height,
 849 #endif
 850                            vo_doublebuffering);
 851         prev_width = width;
 852         prev_height = height;
 853     }
 854
 855     mp_msg(MSGT_VO, MSGL_V, "vo_dga: Using %d frame buffer%s.\n",
 856            vo_dga_nr_video_buffers,
 857            vo_dga_nr_video_buffers == 1 ? "" : "s");
 858
 859     vo_dga_is_running = 1;
 860     return 0;
 861 }
 862
 863 static int dga_depths_init = 0;
 864
 865 static int preinit(const char *arg)
 866 {
 867     if (arg)
 868     {
 869         mp_msg(MSGT_VO, MSGL_INFO, "vo_dga: Unknown subdevice: %s\n", arg);
 870         return ENOSYS;
 871     }
 872
 873     if (!vo_init())
 874         return -1;              // Can't open X11
 875
 876     if (dga_depths_init == 0)
 877     {                           // FIXME!?
 878         int i;
 879
 880         vo_dga_XServer_mode = vd_ValidateMode(vo_depthonscreen);
 881
 882         if (vo_dga_XServer_mode == 0)
 883         {
 884 #ifndef HAVE_DGA2
 885             mp_msg(MSGT_VO, MSGL_ERR,
 886                    "vo_dga: Your X-Server is not running in a ");
 887             mp_msg(MSGT_VO, MSGL_ERR,
 888                    "resolution supported by DGA driver!\n");
 889 #endif
 890         }                       //else{
 891         //  mp_msg(MSGT_VO, MSGL_V, "vo_dga: X running at: %s\n",
 892         //            vd_GetModeString(vo_dga_XServer_mode));
 893         //}
 894
 895 #ifdef HAVE_DGA2
 896         vo_modelines = XDGAQueryModes(mDisplay, mScreen, &vo_modecount);
 897         if (vo_modelines)
 898         {
 899             for (i = 0; i < vo_modecount; i++)
 900             {
 901                 mp_msg(MSGT_VO, MSGL_V,
 902                        "vo_dga: (%03d) depth=%d, bpp=%d, r=%08lx, g=%08lx, b=%08lx, %d x %d\n",
 903                        i, vo_modelines[i].depth,
 904                        vo_modelines[i].bitsPerPixel,
 905                        vo_modelines[i].redMask, vo_modelines[i].greenMask,
 906                        vo_modelines[i].blueMask,
 907                        vo_modelines[i].viewportWidth,
 908                        vo_modelines[i].viewportHeight);
 909                 vd_EnableMode(vo_modelines[i].depth,
 910                               vo_modelines[i].bitsPerPixel,
 911                               vo_modelines[i].redMask,
 912                               vo_modelines[i].greenMask,
 913                               vo_modelines[i].blueMask);
 914             }
 915         }
 916 #endif
 917         dga_depths_init = 1;
 918
 919         if (!vo_dga_modes[1].vdm_supported
 920             && vo_dga_modes[2].vdm_supported)
 921         {
 922             vo_dga_modes[1].vdm_supported = 1;
 923         }
 924
 925         if (!vo_dga_modes[3].vdm_supported
 926             && vo_dga_modes[4].vdm_supported)
 927         {
 928             vo_dga_modes[3].vdm_supported = 1;
 929         }
 930
 931         for (i = 1; i < vo_dga_mode_num; i++)
 932         {
 933             mp_msg(MSGT_VO, MSGL_INFO, "vo_dga: Mode: %s",
 934                    vd_GetModeString(i));
 935             if (vo_dbpp && vo_dbpp != vo_dga_modes[i].vdm_mplayer_depth)
 936             {
 937                 vo_dga_modes[i].vdm_supported = 0;
 938                 mp_msg(MSGT_VO, MSGL_INFO, " ...disabled by -bpp %d",
 939                        vo_dbpp);
 940             }
 941             mp_msg(MSGT_VO, MSGL_INFO, "\n");
 942         }
 943     }
 944
 945     return 0;
 946 }
 947
 948 static uint32_t get_image(mp_image_t * mpi)
 949 {
 950     if (!IMGFMT_IS_BGR(mpi->imgfmt) ||
 951         (IMGFMT_BGR_DEPTH(mpi->imgfmt) !=
 952          vo_dga_modes[vo_dga_hw_mode].vdm_mplayer_depth)
 953         || (mpi->type == MP_IMGTYPE_STATIC && vo_dga_nr_video_buffers > 1)
 954         || (mpi->type == MP_IMGTYPE_IP && vo_dga_nr_video_buffers < 2)
 955         || (mpi->type == MP_IMGTYPE_IPB))
 956         return (VO_FALSE);
 957
 958     if ((mpi->flags & MP_IMGFLAG_ACCEPT_STRIDE) ||
 959         (mpi->flags & MP_IMGFLAG_ACCEPT_WIDTH &&
 960          ((vo_dga_bytes_per_line + vo_dga_vp_skip) % (mpi->bpp / 8)) == 0)
 961         || (mpi->width * (mpi->bpp / 8) ==
 962             (vo_dga_bytes_per_line + vo_dga_vp_skip)))
 963     {
 964
 965         mpi->planes[0] = CURRENT_VIDEO_BUFFER.data + vo_dga_vp_offset;
 966         mpi->stride[0] = vo_dga_bytes_per_line + vo_dga_vp_skip;
 967         mpi->width =
 968             (vo_dga_bytes_per_line + vo_dga_vp_skip) / (mpi->bpp / 8);
 969         mpi->flags |= MP_IMGFLAG_DIRECT;
 970         return (VO_TRUE);
 971     }
 972
 973     return (VO_FALSE);
 974 }
 975
 976 static int control(uint32_t request, void *data, ...)
 977 {
 978     switch (request)
 979     {
 980         case VOCTRL_GET_IMAGE:
 981             return get_image(data);
 982         case VOCTRL_QUERY_FORMAT:
 983             return query_format(*((uint32_t *) data));
 984     }
 985     return VO_NOTIMPL;
 986 }
 987
 988 //---------------------------------------------------------