/* _xdga2_fetch_mode_list:
* Creates list of available DGA2 video modes.
*/
static GFX_MODE_LIST *_xdga2_private_fetch_mode_list(void)
{
XDGAMode *mode;
int bpp, num_modes, stored_modes, i, j, already_there;
GFX_MODE_LIST *mode_list;
GFX_MODE *tmp;
mode = XDGAQueryModes(_xwin.display, _xwin.screen, &num_modes);
if (!mode)
return NULL;
mode_list = _AL_MALLOC(sizeof(GFX_MODE_LIST));
if (!mode_list)
goto error;
mode_list->mode = NULL;
stored_modes = 0;
for (i=0; i<num_modes; i++) {
bpp = (mode[i].depth == 24) ? mode[i].bitsPerPixel : mode[i].depth;
already_there = FALSE;
for (j=0; j<stored_modes; j++) {
if ((mode_list->mode[j].width == mode[i].viewportWidth) &&
(mode_list->mode[j].height == mode[i].viewportHeight) &&
(mode_list->mode[j].bpp == bpp)) {
already_there = TRUE;
break;
}
}
if (!already_there) {
tmp = _AL_REALLOC(mode_list->mode, sizeof(GFX_MODE) * (stored_modes + 1));
if (!tmp)
goto error;
mode_list->mode = tmp;
mode_list->mode[stored_modes].width = mode[i].viewportWidth;
mode_list->mode[stored_modes].height = mode[i].viewportHeight;
mode_list->mode[stored_modes].bpp = bpp;
stored_modes++;
}
}
tmp = _AL_REALLOC(mode_list->mode, sizeof(GFX_MODE) * (stored_modes + 1));
if (!tmp)
goto error;
mode_list->mode = tmp;
mode_list->mode[stored_modes].width = 0;
mode_list->mode[stored_modes].height = 0;
mode_list->mode[stored_modes].bpp = 0;
mode_list->num_modes = stored_modes;
XFree(mode);
return mode_list;
error:
if (mode_list) {
_AL_FREE(mode_list->mode);
_AL_FREE(mode_list);
}
XFree(mode);
return NULL;
}
/* _xdga2_find_mode:
* Returns id number of specified video mode if available, 0 otherwise.
*/
static int _xdga2_find_mode(int w, int h, int vw, int vh, int depth)
{
XDGAMode *mode;
int num_modes;
int bpp, i, found;
mode = XDGAQueryModes(_xwin.display, _xwin.screen, &num_modes);
if (!mode)
return 0;
/* Let's first try setting also requested refresh rate */
for (i=0; i<num_modes; i++) {
bpp = mode[i].depth;
if (bpp == 24) bpp = mode[i].bitsPerPixel;
if ((mode[i].viewportWidth == w) &&
(mode[i].viewportHeight == h) &&
(mode[i].imageWidth >= vw) &&
(mode[i].imageHeight >= vh) &&
(mode[i].verticalRefresh >= _refresh_rate_request) &&
(bpp == depth)) break;
}
if (i == num_modes) {
/* No modes were found, so now we don't care about refresh rate */
for (i=0; i<num_modes; i++) {
bpp = mode[i].depth;
if (bpp == 24) bpp = mode[i].bitsPerPixel;
if ((mode[i].viewportWidth == w) &&
(mode[i].viewportHeight == h) &&
(mode[i].imageWidth >= vw) &&
(mode[i].imageHeight >= vh) &&
(bpp == depth)) break;
}
if (i == num_modes) {
/* No way out: mode not found */
XFree(mode);
return 0;
}
}
found = mode[i].num;
XFree(mode);
return found;
}
static int ggi_xdga_getmodelist(struct ggi_visual * vis)
{
ggi_x_priv *priv;
XDGAMode *modes;
int screen;
priv = GGIX_PRIV(vis);
screen = priv->vilist[priv->viidx].vi->screen;
priv->modes_num = 0;
priv->modes_priv = modes =
XDGAQueryModes(priv->disp, screen, &(priv->modes_num));
if (priv->modes_priv == NULL)
return GGI_ENODEVICE;
if (priv->modes_num <= 0)
return GGI_ENODEVICE;
return GGI_OK;
}
static int
vinit( video_module_t *module )
{
int n, i, major, minor, mcount, nodga;
int (*old_ehandler)(Display*, XErrorEvent*);
Display *dis = x11.disp;
XDGAMode *mm;
video_desc_t *m;
memset( &dga, 0, sizeof(dga) );
if( !x11.connected || get_bool_res("enable_xdga_video")!=1 )
return 1;
nodga = !XDGAQueryExtension(dis, &dga.ev_base, &dga.err_base);
old_ehandler = XSetErrorHandler( dga_error_handler );
nodga = nodga || !XDGAQueryVersion(dis, &major, &minor);
XSetErrorHandler( old_ehandler );
if( nodga ) {
printm("X11 DGA is not available\n");
return 1;
}
if( major < MIN_MAJOR || (major == MIN_MAJOR && minor < MIN_MINOR) ) {
printm("Xserver is running DGA %d.%d (%d.%d is required)\n",
major, minor, MIN_MAJOR, MIN_MINOR );
return 1;
}
printm("Running X11 DGA %d.%d\n\n", major, minor );
if( !(mm=XDGAQueryModes(dis, x11.screen, &mcount)) ) {
printm("XDGAQueryModes failed\n");
return 1;
}
m = calloc( mcount, sizeof(video_desc_t) );
for( n=0, i=0; i<mcount; i++ ) {
int j, skip = 0;
char *s;
for( j=0; (s=get_str_res_ind("xdga_modes", 0, j)); j++ ) {
skip = 1;
if( i == strtol(s,NULL,0) )
break;
}
if( mm[i].visualClass != DirectColor /*&& mm[i].visualClass != PseudoColor*/ )
skip = 1;
if( mm[i].bitsPerPixel == 24 || mm[i].depth == 16 || mm[i].depth != x11.xdepth )
skip = 1;
if( s )
skip = 0;
printm(" %c Mode %d: \"%s\": %dx%d %2d (%dx%d) %.2f Hz %04x %d %d\n",
skip ? ' ' : '*', mm[i].num, mm[i].name,
mm[i].imageWidth, mm[i].imageHeight,
mm[i].depth, mm[i].pixmapWidth, mm[i].pixmapHeight,
mm[i].verticalRefresh,
/*mm[i].viewportWidth, mm[i].viewportHeight, */
mm[i].flags, mm[i].bytesPerScanline, mm[i].visualClass
);
if( skip )
continue;
/* add mode */
m[n].offs = 0; /* fixme! */
m[n].rowbytes = mm[i].bytesPerScanline;
m[n].w = mm[i].viewportWidth;
m[n].h = mm[i].viewportHeight;
m[n].depth = mm[i].depth;
m[n].refresh = (mm[i].verticalRefresh * 65536) + 0.5;
m[n].module_data = (void*)mm[i].num;
m[n].next = NULL;
if( n>0 )
m[n-1].next = &m[n];
n++;
}
printm("\n");
xdga_module.modes = &m[0];
XFree( mm );
add_key_actions( xdga_keys, sizeof(xdga_keys) );
dga.initialized = 1;
return 0;
}
static int preinit(const char *arg)
{
if (arg)
{
mp_msg(MSGT_VO, MSGL_INFO, "vo_dga: Unknown subdevice: %s\n", arg);
return ENOSYS;
}
if (!vo_init())
return -1; // Can't open X11
if (dga_depths_init == 0)
{ // FIXME!?
int i;
vo_dga_XServer_mode = vd_ValidateMode(vo_depthonscreen);
if (vo_dga_XServer_mode == 0)
{
#ifndef HAVE_DGA2
mp_msg(MSGT_VO, MSGL_ERR,
"vo_dga: Your X-Server is not running in a ");
mp_msg(MSGT_VO, MSGL_ERR,
"resolution supported by DGA driver!\n");
#endif
} //else{
// mp_msg(MSGT_VO, MSGL_V, "vo_dga: X running at: %s\n",
// vd_GetModeString(vo_dga_XServer_mode));
//}
#ifdef HAVE_DGA2
vo_modelines = XDGAQueryModes(mDisplay, mScreen, &vo_modecount);
if (vo_modelines)
{
for (i = 0; i < vo_modecount; i++)
{
mp_msg(MSGT_VO, MSGL_V,
"vo_dga: (%03d) depth=%d, bpp=%d, r=%08lx, g=%08lx, b=%08lx, %d x %d\n",
i, vo_modelines[i].depth,
vo_modelines[i].bitsPerPixel,
vo_modelines[i].redMask, vo_modelines[i].greenMask,
vo_modelines[i].blueMask,
vo_modelines[i].viewportWidth,
vo_modelines[i].viewportHeight);
vd_EnableMode(vo_modelines[i].depth,
vo_modelines[i].bitsPerPixel,
vo_modelines[i].redMask,
vo_modelines[i].greenMask,
vo_modelines[i].blueMask);
}
}
#endif
dga_depths_init = 1;
if (!vo_dga_modes[1].vdm_supported
&& vo_dga_modes[2].vdm_supported)
{
vo_dga_modes[1].vdm_supported = 1;
}
if (!vo_dga_modes[3].vdm_supported
&& vo_dga_modes[4].vdm_supported)
{
vo_dga_modes[3].vdm_supported = 1;
}
for (i = 1; i < vo_dga_mode_num; i++)
{
mp_msg(MSGT_VO, MSGL_INFO, "vo_dga: Mode: %s",
vd_GetModeString(i));
if (vo_dbpp && vo_dbpp != vo_dga_modes[i].vdm_mplayer_depth)
{
vo_dga_modes[i].vdm_supported = 0;
mp_msg(MSGT_VO, MSGL_INFO, " ...disabled by -bpp %d",
vo_dbpp);
}
mp_msg(MSGT_VO, MSGL_INFO, "\n");
}
}
return 0;
}
static int xf86_dga_vidmode_find_best_vidmode(void)
{
int i;
int bestmode = -1;
int score, best_score = 0;
#ifdef TDFX_DGA_WORKAROUND
int dotclock;
XF86VidModeModeLine modeline;
XF86VidModeGetModeLine(display, xf86ctx.screen, &dotclock, &modeline);
#endif
if (!xf86ctx.modes)
{
xf86ctx.modes = XDGAQueryModes(display, xf86ctx.screen, &xf86ctx.mode_count);
fprintf(stderr, "XDGA: info: found %d modes:\n", xf86ctx.mode_count);
}
/* also determine the max size of the display */
sysdep_display_properties.max_width = 0;
sysdep_display_properties.max_height = 0;
for(i=0;i<xf86ctx.mode_count;i++)
{
#ifdef TDFX_DGA_WORKAROUND
if ((xf86ctx.current_mode == -1) &&
xf86ctx.modes[i].viewportWidth == modeline.hdisplay &&
xf86ctx.modes[i].viewportHeight == modeline.vdisplay)
xf86ctx.current_X11_mode = xf86ctx.modes[i].num;
#endif
#if 0 /* DEBUG */
fprintf(stderr, "XDGA: info: (%d) %s\n",
xf86ctx.modes[i].num, xf86ctx.modes[i].name);
fprintf(stderr, " : VRefresh = %f [Hz]\n",
xf86ctx.modes[i].verticalRefresh);
/* flags */
fprintf(stderr, " : viewport = %dx%d\n",
xf86ctx.modes[i].viewportWidth, xf86ctx.modes[i].viewportHeight);
fprintf(stderr, " : image = %dx%d\n",
xf86ctx.modes[i].imageWidth, xf86ctx.modes[i].imageHeight);
if (xf86ctx.modes[i].flags & XDGAPixmap)
fprintf(stderr, " : pixmap = %dx%d\n",
xf86ctx.modes[i].pixmapWidth, xf86ctx.modes[i].pixmapHeight);
fprintf(stderr, " : bytes/scanline = %d\n",
xf86ctx.modes[i].bytesPerScanline);
fprintf(stderr, " : byte order = %s\n",
xf86ctx.modes[i].byteOrder == MSBFirst ? "MSBFirst" :
xf86ctx.modes[i].byteOrder == LSBFirst ? "LSBFirst" :
"Unknown");
fprintf(stderr, " : bpp = %d, depth = %d\n",
xf86ctx.modes[i].bitsPerPixel, xf86ctx.modes[i].depth);
fprintf(stderr, " : RGBMask = (%lx, %lx, %lx)\n",
xf86ctx.modes[i].redMask,
xf86ctx.modes[i].greenMask,
xf86ctx.modes[i].blueMask);
fprintf(stderr, " : visual class = %s\n",
xf86ctx.modes[i].visualClass == TrueColor ? "TrueColor":
xf86ctx.modes[i].visualClass == DirectColor ? "DirectColor" :
xf86ctx.modes[i].visualClass == PseudoColor ? "PseudoColor" : "Unknown");
fprintf(stderr, " : xViewportStep = %d, yViewportStep = %d\n",
xf86ctx.modes[i].xViewportStep, xf86ctx.modes[i].yViewportStep);
fprintf(stderr, " : maxViewportX = %d, maxViewportY = %d\n",
xf86ctx.modes[i].maxViewportX, xf86ctx.modes[i].maxViewportY);
/* viewportFlags */
#endif
/* we only support TrueColor visuals */
if(xf86ctx.modes[i].visualClass != TrueColor)
continue;
score = mode_match(xf86ctx.modes[i].viewportWidth,
xf86ctx.modes[i].viewportHeight,
xf86ctx.modes[i].bytesPerScanline * 8 /
xf86ctx.modes[i].bitsPerPixel,
xf86ctx.modes[i].depth,
xf86ctx.modes[i].bitsPerPixel);
if(score > best_score)
{
best_score = score;
bestmode = xf86ctx.modes[i].num;
}
/* also determine the max size of the display */
if(xf86ctx.modes[i].viewportWidth > sysdep_display_properties.max_width)
sysdep_display_properties.max_width = xf86ctx.modes[i].viewportWidth;
if(xf86ctx.modes[i].viewportHeight > sysdep_display_properties.max_height)
sysdep_display_properties.max_height = xf86ctx.modes[i].viewportHeight;
}
return bestmode;
}
