mirror of
https://github.com/mpv-player/mpv
synced 2024-12-26 17:12:36 +00:00
1000 lines
31 KiB
C
1000 lines
31 KiB
C
/*
|
|
* X11 DGA Interface
|
|
*
|
|
* Copyright (C) 2001 Andreas Ackermann <acki@acki-netz.de>
|
|
* Sourceforge username: acki2
|
|
*
|
|
* This file is part of MPlayer.
|
|
*
|
|
* MPlayer 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 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* MPlayer 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 MPlayer; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
|
|
#include "config.h"
|
|
#include "video_out.h"
|
|
#include "video_out_internal.h"
|
|
#include "aspect.h"
|
|
#include "x11_common.h"
|
|
#include "fastmemcpy.h"
|
|
#include "mp_msg.h"
|
|
|
|
#include <X11/Xlib.h>
|
|
#include <X11/extensions/Xxf86dga.h>
|
|
|
|
#ifdef CONFIG_XF86VM
|
|
#include <X11/extensions/xf86vmode.h>
|
|
#endif
|
|
|
|
static const vo_info_t info = {
|
|
#ifdef CONFIG_DGA2
|
|
"DGA ( Direct Graphic Access V2.0 )",
|
|
#else
|
|
#ifdef CONFIG_XF86VM
|
|
"DGA ( Direct Graphic Access V1.0+XF86VidModeExt. )",
|
|
#else
|
|
"DGA ( Direct Graphic Access V1.0 )",
|
|
#endif
|
|
#endif
|
|
"dga",
|
|
"Andreas Ackermann <acki@acki-netz.de>",
|
|
""
|
|
};
|
|
|
|
const LIBVO_EXTERN(dga)
|
|
//------------------------------------------------------------------
|
|
//#define BITSPP (vo_dga_modes[vo_dga_active_mode].vdm_bitspp)
|
|
//#define BYTESPP (vo_dga_modes[vo_dga_active_mode].vdm_bytespp)
|
|
#define VO_DGA_INVALID_RES 100000
|
|
#define HW_MODE (vo_dga_modes[vo_dga_hw_mode])
|
|
#define SRC_MODE (vo_dga_modes[vo_dga_src_mode])
|
|
struct vd_modes
|
|
{
|
|
int vdm_mplayer_depth;
|
|
int vdm_supported;
|
|
int vdm_depth;
|
|
int vdm_bitspp;
|
|
int vdm_bytespp;
|
|
int vdm_rmask;
|
|
int vdm_gmask;
|
|
int vdm_bmask;
|
|
int vdm_hw_mode;
|
|
};
|
|
|
|
//------------------------------------------------------------------
|
|
|
|
static struct vd_modes vo_dga_modes[] = {
|
|
// these entries describe HW modes
|
|
// however, we use the same entries to tell mplayer what we support
|
|
// so the last two values describe, which HW mode to use and which conversion
|
|
// function to use for a mode that is not supported by HW
|
|
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0,},
|
|
{15, 0, 15, 16, 2, 0x7c00, 0x03e0, 0x001f, 2,},
|
|
{16, 0, 16, 16, 2, 0xf800, 0x07e0, 0x001f, 2,},
|
|
{24, 0, 24, 24, 3, 0xff0000, 0x00ff00, 0x0000ff, 4},
|
|
{32, 0, 24, 32, 4, 0x00ff0000, 0x0000ff00, 0x000000ff, 4}
|
|
};
|
|
|
|
static int vo_dga_mode_num =
|
|
sizeof(vo_dga_modes) / sizeof(struct vd_modes);
|
|
|
|
// enable a HW mode (by description)
|
|
static int vd_EnableMode(int depth, int bitspp,
|
|
int rmask, int gmask, int bmask)
|
|
{
|
|
int i;
|
|
|
|
for (i = 1; i < vo_dga_mode_num; i++)
|
|
{
|
|
if (vo_dga_modes[i].vdm_depth == depth &&
|
|
vo_dga_modes[i].vdm_bitspp == bitspp &&
|
|
vo_dga_modes[i].vdm_rmask == rmask &&
|
|
vo_dga_modes[i].vdm_gmask == gmask &&
|
|
vo_dga_modes[i].vdm_bmask == bmask)
|
|
{
|
|
vo_dga_modes[i].vdm_supported = 1;
|
|
vo_dga_modes[i].vdm_hw_mode = i;
|
|
return i;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int vd_ModeEqual(int depth, int bitspp,
|
|
int rmask, int gmask, int bmask, int index)
|
|
{
|
|
return (vo_dga_modes[index].vdm_depth == depth &&
|
|
vo_dga_modes[index].vdm_bitspp == bitspp &&
|
|
vo_dga_modes[index].vdm_rmask == rmask &&
|
|
vo_dga_modes[index].vdm_gmask == gmask &&
|
|
vo_dga_modes[index].vdm_bmask == bmask) ? 1 : 0;
|
|
}
|
|
|
|
|
|
// enable a HW mode (mplayer_depth decides which)
|
|
static int vd_ValidateMode(int mplayer_depth)
|
|
{
|
|
int i;
|
|
|
|
if (mplayer_depth == 0)
|
|
return 0;
|
|
for (i = 1; i < vo_dga_mode_num; i++)
|
|
{
|
|
if (vo_dga_modes[i].vdm_mplayer_depth == mplayer_depth)
|
|
{
|
|
vo_dga_modes[i].vdm_supported = 1;
|
|
vo_dga_modes[i].vdm_hw_mode = i;
|
|
return i;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// do we support this mode? (not important whether native or conversion)
|
|
static int vd_ModeValid(int mplayer_depth)
|
|
{
|
|
int i;
|
|
|
|
if (mplayer_depth == 0)
|
|
return 0;
|
|
for (i = 1; i < vo_dga_mode_num; i++)
|
|
{
|
|
if (vo_dga_modes[i].vdm_mplayer_depth == mplayer_depth &&
|
|
vo_dga_modes[i].vdm_supported != 0)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static char *vd_GetModeString(int index)
|
|
{
|
|
|
|
#define VO_DGA_MAX_STRING_LEN 100
|
|
static char stringbuf[VO_DGA_MAX_STRING_LEN];
|
|
|
|
stringbuf[VO_DGA_MAX_STRING_LEN - 1] = 0;
|
|
snprintf(stringbuf, VO_DGA_MAX_STRING_LEN - 2,
|
|
"depth=%d, bpp=%d, r=%06x, g=%06x, b=%06x, %s (-bpp %d)",
|
|
vo_dga_modes[index].vdm_depth,
|
|
vo_dga_modes[index].vdm_bitspp,
|
|
vo_dga_modes[index].vdm_rmask,
|
|
vo_dga_modes[index].vdm_gmask,
|
|
vo_dga_modes[index].vdm_bmask,
|
|
vo_dga_modes[index].
|
|
vdm_supported ? "native" : "not supported",
|
|
vo_dga_modes[index].vdm_mplayer_depth);
|
|
return stringbuf;
|
|
}
|
|
|
|
//-----------------------------------------------------------------
|
|
|
|
#if defined(CONFIG_XF86VM) && !defined(CONFIG_DGA2)
|
|
static XF86VidModeModeInfo **vo_dga_vidmodes = NULL;
|
|
#endif
|
|
|
|
|
|
static int vo_dga_src_format;
|
|
static int vo_dga_width; // bytes per line in framebuffer
|
|
static int vo_dga_vp_width; // visible pixels per line in
|
|
|
|
// framebuffer
|
|
static int vo_dga_vp_height; // visible lines in framebuffer
|
|
static int vo_dga_is_running = 0;
|
|
static int vo_dga_src_width; // width of video in pixels
|
|
static int vo_dga_src_height; // height of video in pixels
|
|
static int vo_dga_src_offset = 0; // offset in src
|
|
static int vo_dga_vp_offset = 0; // offset in dest
|
|
static int vo_dga_bytes_per_line; // bytes per line to copy
|
|
static int vo_dga_vp_skip; // dto. for dest
|
|
static int vo_dga_lines; // num of lines to copy
|
|
static int vo_dga_hw_mode = 0; // index in mode list that is actually
|
|
|
|
// used by framebuffer
|
|
static int vo_dga_src_mode = 0; // index in mode list that is used by
|
|
|
|
// codec
|
|
static int vo_dga_XServer_mode = 0; // index in mode list for resolution
|
|
|
|
#ifdef CONFIG_DGA2
|
|
static XDGAMode *vo_modelines;
|
|
static int vo_modecount;
|
|
#endif
|
|
|
|
#define MAX_NR_VIDEO_BUFFERS 3
|
|
|
|
#define CURRENT_VIDEO_BUFFER \
|
|
(vo_dga_video_buffer[vo_dga_current_video_buffer])
|
|
|
|
static int vo_dga_nr_video_buffers; // Total number of frame buffers.
|
|
static int vo_dga_current_video_buffer; // Buffer available for rendering.
|
|
|
|
static struct video_buffer
|
|
{
|
|
int y;
|
|
uint8_t *data;
|
|
} vo_dga_video_buffer[MAX_NR_VIDEO_BUFFERS];
|
|
|
|
/* saved src and dst dimensions for SwScaler */
|
|
static unsigned int scale_srcW = 0,
|
|
scale_dstW = 0, scale_srcH = 0, scale_dstH = 0;
|
|
|
|
//---------------------------------------------------------
|
|
|
|
static void draw_alpha(int x0, int y0, int w, int h, unsigned char *src,
|
|
unsigned char *srca, int stride)
|
|
{
|
|
|
|
char *d;
|
|
unsigned int offset;
|
|
int buffer_stride;
|
|
|
|
offset = vo_dga_width * y0 + x0;
|
|
buffer_stride = vo_dga_width;
|
|
d = CURRENT_VIDEO_BUFFER.data + vo_dga_vp_offset;
|
|
|
|
switch (HW_MODE.vdm_mplayer_depth)
|
|
{
|
|
|
|
case 32:
|
|
vo_draw_alpha_rgb32(w, h, src, srca, stride, d + 4 * offset,
|
|
4 * buffer_stride);
|
|
break;
|
|
case 24:
|
|
vo_draw_alpha_rgb24(w, h, src, srca, stride, d + 3 * offset,
|
|
3 * buffer_stride);
|
|
break;
|
|
case 15:
|
|
vo_draw_alpha_rgb15(w, h, src, srca, stride, d + 2 * offset,
|
|
2 * buffer_stride);
|
|
break;
|
|
case 16:
|
|
vo_draw_alpha_rgb16(w, h, src, srca, stride, d + 2 * offset,
|
|
2 * buffer_stride);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
// quick & dirty - for debugging only
|
|
#if 0
|
|
static void fillblock(char *strt, int yoff, int lines, int val)
|
|
{
|
|
char *i;
|
|
|
|
for (i = strt + yoff * vo_dga_width * HW_MODE.vdm_bytespp;
|
|
i < strt + (lines + yoff) * vo_dga_width * HW_MODE.vdm_bytespp;)
|
|
{
|
|
*i++ = val;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
//---------------------------------------------------------
|
|
|
|
static int draw_frame(uint8_t * src[])
|
|
{
|
|
|
|
int numlines = vo_dga_lines;
|
|
|
|
char *s, *d;
|
|
|
|
s = *src;
|
|
d = CURRENT_VIDEO_BUFFER.data + vo_dga_vp_offset;
|
|
|
|
mem2agpcpy_pic(d, s,
|
|
vo_dga_bytes_per_line,
|
|
numlines,
|
|
vo_dga_bytes_per_line + vo_dga_vp_skip,
|
|
vo_dga_bytes_per_line);
|
|
|
|
// DBG-COde
|
|
|
|
#if 0
|
|
d = CURRENT_VIDEO_BUFFER.data + vo_dga_vp_offset;
|
|
fillblock(d, 0, 10, 0x800000ff);
|
|
fillblock(d, 10, 10, 0x8000ff00);
|
|
fillblock(d, 20, 10, 0x80ff0000);
|
|
fillblock(d, 30, 10, 0xff0000ff);
|
|
fillblock(d, 40, 10, 0x800000ff);
|
|
fillblock(d, 50, 10, 0x0f0000ff);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
|
|
static void check_events(void)
|
|
{
|
|
vo_x11_check_events(mDisplay);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
|
|
#include "sub/sub.h"
|
|
|
|
static void draw_osd(void)
|
|
{
|
|
vo_draw_text(vo_dga_src_width, vo_dga_src_height, draw_alpha);
|
|
}
|
|
|
|
static void switch_video_buffers(void)
|
|
{
|
|
vo_dga_current_video_buffer =
|
|
(vo_dga_current_video_buffer + 1) % vo_dga_nr_video_buffers;
|
|
}
|
|
|
|
static void flip_page(void)
|
|
{
|
|
if (1 < vo_dga_nr_video_buffers)
|
|
{
|
|
#ifdef CONFIG_DGA2
|
|
XDGASetViewport(mDisplay, mScreen,
|
|
0, CURRENT_VIDEO_BUFFER.y, XDGAFlipRetrace);
|
|
#else
|
|
XF86DGASetViewPort(mDisplay, mScreen, 0, CURRENT_VIDEO_BUFFER.y);
|
|
#endif
|
|
switch_video_buffers();
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
|
|
static int draw_slice(uint8_t * src[], int stride[],
|
|
int w, int h, int x, int y)
|
|
{
|
|
return 0;
|
|
};
|
|
|
|
//---------------------------------------------------------
|
|
|
|
static int query_format(uint32_t format)
|
|
{
|
|
|
|
if ((format & IMGFMT_BGR_MASK) == IMGFMT_BGR &&
|
|
vd_ModeValid(format & 0xff))
|
|
{
|
|
return VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW | VFCAP_OSD;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
|
|
static void uninit(void)
|
|
{
|
|
|
|
#ifdef CONFIG_DGA2
|
|
XDGADevice *dgadevice;
|
|
#endif
|
|
|
|
if (!vo_config_count)
|
|
return;
|
|
|
|
if (vo_dga_is_running)
|
|
{
|
|
vo_dga_is_running = 0;
|
|
mp_msg(MSGT_VO, MSGL_V, "vo_dga: in uninit\n");
|
|
if (vo_grabpointer)
|
|
XUngrabPointer(mDisplay, CurrentTime);
|
|
XUngrabKeyboard(mDisplay, CurrentTime);
|
|
#ifdef CONFIG_DGA2
|
|
XDGACloseFramebuffer(mDisplay, mScreen);
|
|
dgadevice = XDGASetMode(mDisplay, mScreen, 0);
|
|
if (dgadevice != NULL)
|
|
{
|
|
XFree(dgadevice);
|
|
}
|
|
#else
|
|
XF86DGADirectVideo(mDisplay, mScreen, 0);
|
|
// first disable DirectVideo and then switch mode back!
|
|
#ifdef CONFIG_XF86VM
|
|
if (vo_dga_vidmodes != NULL)
|
|
{
|
|
int screen;
|
|
|
|
screen = XDefaultScreen(mDisplay);
|
|
mp_msg(MSGT_VO, MSGL_V,
|
|
"vo_dga: VidModeExt: Switching back..\n");
|
|
// seems some graphics adaptors need this more than once ...
|
|
XF86VidModeSwitchToMode(mDisplay, screen, vo_dga_vidmodes[0]);
|
|
XF86VidModeSwitchToMode(mDisplay, screen, vo_dga_vidmodes[0]);
|
|
XF86VidModeSwitchToMode(mDisplay, screen, vo_dga_vidmodes[0]);
|
|
XF86VidModeSwitchToMode(mDisplay, screen, vo_dga_vidmodes[0]);
|
|
XFree(vo_dga_vidmodes);
|
|
}
|
|
#endif
|
|
#endif
|
|
}
|
|
vo_x11_uninit();
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------
|
|
// TODO: check for larger maxy value
|
|
// (useful for double buffering!!!)
|
|
|
|
static int check_res(int num, int x, int y, int bpp,
|
|
int new_x, int new_y, int new_vbi, int new_maxy,
|
|
int *old_x, int *old_y, int *old_vbi, int *old_maxy)
|
|
{
|
|
|
|
mp_msg(MSGT_VO, MSGL_V,
|
|
"vo_dga: (%3d) Trying %4d x %4d @ %3d Hz @ depth %2d ..", num,
|
|
new_x, new_y, new_vbi, bpp);
|
|
mp_msg(MSGT_VO, MSGL_V, "(old: %dx%d@%d).", *old_x, *old_y, *old_vbi);
|
|
if ((new_x >= x) && (new_y >= y) && (
|
|
// prefer a better resolution either in X or in Y
|
|
// as long as the other dimension is at least the same
|
|
//
|
|
// hmm ... MAYBE it would be more clever to focus on the
|
|
// x-resolution; I had 712x400 and 640x480 and the movie
|
|
// was 640x360; 640x480 would be the 'right thing' here
|
|
// but since 712x400 was queried first I got this one.
|
|
// I think there should be a cmd-line switch to let the
|
|
// user choose the mode he likes ... (acki2)
|
|
(((new_x < *old_x) &&
|
|
!(new_y > *old_y)) ||
|
|
((new_y < *old_y) &&
|
|
!(new_x > *old_x)))
|
|
// but if we get an identical resolution choose
|
|
// the one with the lower refreshrate (saves bandwidth !!!)
|
|
// as long as it's above 50 Hz (acki2 on 30/3/2001)
|
|
||
|
|
(((new_x == *old_x) &&
|
|
(new_y == *old_y) &&
|
|
((new_vbi >= *old_vbi
|
|
&& *old_vbi < 50)
|
|
|| (*old_vbi >= 50
|
|
&& new_vbi < *old_vbi
|
|
&& new_vbi >= 50))) ||
|
|
// if everything is equal, then use the mode with the lower
|
|
// stride
|
|
((new_x == *old_x) &&
|
|
(new_y == *old_y) &&
|
|
(new_vbi == *old_vbi) &&
|
|
(new_maxy > *old_maxy)))))
|
|
{
|
|
*old_x = new_x;
|
|
*old_y = new_y;
|
|
*old_maxy = new_maxy;
|
|
*old_vbi = new_vbi;
|
|
mp_msg(MSGT_VO, MSGL_V, ".ok!!\n");
|
|
return 1;
|
|
} else
|
|
{
|
|
mp_msg(MSGT_VO, MSGL_V, ".no\n");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------
|
|
|
|
static void init_video_buffers(uint8_t * buffer_base,
|
|
int view_port_height,
|
|
int bytes_per_scanline,
|
|
int max_view_port_y,
|
|
int use_multiple_buffers)
|
|
{
|
|
int bytes_per_buffer = view_port_height * bytes_per_scanline;
|
|
int i;
|
|
|
|
if (use_multiple_buffers)
|
|
vo_dga_nr_video_buffers = max_view_port_y / view_port_height;
|
|
else
|
|
vo_dga_nr_video_buffers = 1;
|
|
|
|
if (vo_dga_nr_video_buffers > MAX_NR_VIDEO_BUFFERS)
|
|
vo_dga_nr_video_buffers = MAX_NR_VIDEO_BUFFERS;
|
|
if (vo_dga_nr_video_buffers <= 0)
|
|
vo_dga_nr_video_buffers = 1;
|
|
|
|
vo_dga_current_video_buffer = 0;
|
|
|
|
for (i = 0; i < vo_dga_nr_video_buffers; i++)
|
|
{
|
|
vo_dga_video_buffer[i].y = i * view_port_height;
|
|
vo_dga_video_buffer[i].data = buffer_base + i * bytes_per_buffer;
|
|
|
|
// Clear video buffer.
|
|
memset(vo_dga_video_buffer[i].data, 0, bytes_per_buffer);
|
|
}
|
|
}
|
|
|
|
static int config(uint32_t width, uint32_t height,
|
|
uint32_t d_width, uint32_t d_height,
|
|
uint32_t flags, char *title, uint32_t format)
|
|
{
|
|
|
|
int x_off, y_off;
|
|
int wanted_width, wanted_height;
|
|
|
|
static unsigned char *vo_dga_base;
|
|
static int prev_width, prev_height;
|
|
|
|
#ifdef CONFIG_DGA2
|
|
// needed to change DGA video mode
|
|
int mX = VO_DGA_INVALID_RES, mY = VO_DGA_INVALID_RES, mVBI =
|
|
100000, mMaxY = 0, i, j = 0;
|
|
int dga_modenum;
|
|
XDGAMode *modeline;
|
|
XDGADevice *dgadevice;
|
|
#else
|
|
#ifdef CONFIG_XF86VM
|
|
unsigned int vm_event, vm_error;
|
|
unsigned int vm_ver, vm_rev;
|
|
int i, j = 0, have_vm = 0;
|
|
int mX = VO_DGA_INVALID_RES, mY = VO_DGA_INVALID_RES, mVBI =
|
|
100000, mMaxY = 0, dga_modenum;
|
|
#endif
|
|
int bank, ram;
|
|
#endif
|
|
|
|
vo_dga_src_format = format;
|
|
|
|
wanted_width = d_width;
|
|
wanted_height = d_height;
|
|
|
|
if (!wanted_height)
|
|
wanted_height = height;
|
|
if (!wanted_width)
|
|
wanted_width = width;
|
|
|
|
if (!vo_dbpp)
|
|
{
|
|
if ((format & IMGFMT_BGR_MASK) == IMGFMT_BGR)
|
|
{
|
|
vo_dga_src_mode = vd_ModeValid(format & 0xff);
|
|
}
|
|
} else
|
|
{
|
|
vo_dga_src_mode = vd_ModeValid(vo_dbpp);
|
|
}
|
|
vo_dga_hw_mode = SRC_MODE.vdm_hw_mode;
|
|
|
|
if (!vo_dga_src_mode)
|
|
{
|
|
mp_msg(MSGT_VO, MSGL_ERR, "vo_dga: unsupported video format!\n");
|
|
return 1;
|
|
}
|
|
|
|
vo_dga_vp_width = vo_screenwidth;
|
|
vo_dga_vp_height = vo_screenheight;
|
|
|
|
mp_msg(MSGT_VO, MSGL_V, "vo_dga: XServer res: %dx%d\n",
|
|
vo_dga_vp_width, vo_dga_vp_height);
|
|
|
|
// choose a suitable mode ...
|
|
|
|
#ifdef CONFIG_DGA2
|
|
// Code to change the video mode added by Michael Graffam
|
|
// mgraffam@idsi.net
|
|
|
|
mp_msg(MSGT_VO, MSGL_V, "vo_dga: vo_modelines=%p, vo_modecount=%d\n",
|
|
vo_modelines, vo_modecount);
|
|
|
|
if (vo_modelines == NULL)
|
|
{
|
|
mp_msg(MSGT_VO, MSGL_ERR, "vo_dga: can't get modelines\n");
|
|
return 1;
|
|
}
|
|
|
|
mp_msg(MSGT_VO, MSGL_INFO,
|
|
"vo_dga: DGA 2.0 available :-) Can switch resolution AND depth!\n");
|
|
for (i = 0; i < vo_modecount; i++)
|
|
{
|
|
if (vd_ModeEqual(vo_modelines[i].depth,
|
|
vo_modelines[i].bitsPerPixel,
|
|
vo_modelines[i].redMask,
|
|
vo_modelines[i].greenMask,
|
|
vo_modelines[i].blueMask, vo_dga_hw_mode))
|
|
{
|
|
|
|
mp_msg(MSGT_VO, MSGL_V, "maxy: %4d, depth: %2d, %4dx%4d, ",
|
|
vo_modelines[i].maxViewportY, vo_modelines[i].depth,
|
|
vo_modelines[i].imageWidth,
|
|
vo_modelines[i].imageHeight);
|
|
if (check_res
|
|
(i, wanted_width, wanted_height, vo_modelines[i].depth,
|
|
vo_modelines[i].viewportWidth,
|
|
vo_modelines[i].viewportHeight,
|
|
(unsigned) vo_modelines[i].verticalRefresh,
|
|
vo_modelines[i].maxViewportY, &mX, &mY, &mVBI, &mMaxY))
|
|
j = i;
|
|
}
|
|
}
|
|
mp_msg(MSGT_VO, MSGL_INFO,
|
|
"vo_dga: Selected hardware mode %4d x %4d @ %3d Hz @ depth %2d, bitspp %2d.\n",
|
|
mX, mY, mVBI, HW_MODE.vdm_depth, HW_MODE.vdm_bitspp);
|
|
mp_msg(MSGT_VO, MSGL_INFO,
|
|
"vo_dga: Video parameters by codec: %3d x %3d, depth %2d, bitspp %2d.\n",
|
|
width, height, SRC_MODE.vdm_depth, SRC_MODE.vdm_bitspp);
|
|
vo_dga_vp_width = mX;
|
|
vo_dga_vp_height = mY;
|
|
|
|
if ((flags & VOFLAG_SWSCALE) || (flags & VOFLAG_FULLSCREEN))
|
|
{ /* -zoom or -fs */
|
|
scale_dstW = (d_width + 7) & ~7;
|
|
scale_dstH = d_height;
|
|
scale_srcW = width;
|
|
scale_srcH = height;
|
|
aspect_save_screenres(mX, mY);
|
|
aspect_save_orig(scale_srcW, scale_srcH);
|
|
aspect_save_prescale(scale_dstW, scale_dstH);
|
|
if (flags & VOFLAG_FULLSCREEN) /* -fs */
|
|
aspect(&scale_dstW, &scale_dstH, A_ZOOM);
|
|
else if (flags & VOFLAG_SWSCALE) /* -fs */
|
|
aspect(&scale_dstW, &scale_dstH, A_NOZOOM);
|
|
mp_msg(MSGT_VO, MSGL_INFO,
|
|
"vo_dga: Aspect corrected size for SwScaler: %4d x %4d.\n",
|
|
scale_dstW, scale_dstH);
|
|
/* XXX this is a hack, but I'm lazy ;-) :: atmos */
|
|
width = scale_dstW;
|
|
height = scale_dstH;
|
|
}
|
|
|
|
vo_dga_width = vo_modelines[j].bytesPerScanline / HW_MODE.vdm_bytespp;
|
|
dga_modenum = vo_modelines[j].num;
|
|
modeline = vo_modelines + j;
|
|
|
|
#else
|
|
|
|
#ifdef CONFIG_XF86VM
|
|
|
|
mp_msg(MSGT_VO, MSGL_INFO,
|
|
"vo_dga: DGA 1.0 compatibility code: Using XF86VidMode for mode switching!\n");
|
|
|
|
if (XF86VidModeQueryExtension(mDisplay, &vm_event, &vm_error))
|
|
{
|
|
XF86VidModeQueryVersion(mDisplay, &vm_ver, &vm_rev);
|
|
mp_msg(MSGT_VO, MSGL_INFO,
|
|
"vo_dga: XF86VidMode Extension v%i.%i\n", vm_ver, vm_rev);
|
|
have_vm = 1;
|
|
} else
|
|
{
|
|
mp_msg(MSGT_VO, MSGL_ERR,
|
|
"vo_dga: XF86VidMode Extension not available.\n");
|
|
}
|
|
|
|
#define GET_VREFRESH(dotclk, x, y)( (((dotclk)/(x))*1000)/(y) )
|
|
|
|
if (have_vm)
|
|
{
|
|
int modecount;
|
|
|
|
XF86VidModeGetAllModeLines(mDisplay, mScreen, &modecount,
|
|
&vo_dga_vidmodes);
|
|
|
|
if (vo_dga_vidmodes != NULL)
|
|
{
|
|
for (i = 0; i < modecount; i++)
|
|
{
|
|
if (check_res(i, wanted_width, wanted_height,
|
|
vo_dga_modes[vo_dga_hw_mode].vdm_depth,
|
|
vo_dga_vidmodes[i]->hdisplay,
|
|
vo_dga_vidmodes[i]->vdisplay,
|
|
GET_VREFRESH(vo_dga_vidmodes[i]->dotclock,
|
|
vo_dga_vidmodes[i]->htotal,
|
|
vo_dga_vidmodes[i]->vtotal),
|
|
0, &mX, &mY, &mVBI, &mMaxY))
|
|
j = i;
|
|
}
|
|
|
|
mp_msg(MSGT_VO, MSGL_INFO,
|
|
"vo_dga: Selected video mode %4d x %4d @ %3d Hz @ depth %2d, bitspp %2d, video %3d x %3d.\n",
|
|
mX, mY, mVBI,
|
|
vo_dga_modes[vo_dga_hw_mode].vdm_depth,
|
|
vo_dga_modes[vo_dga_hw_mode].vdm_bitspp, width, height);
|
|
} else
|
|
{
|
|
mp_msg(MSGT_VO, MSGL_INFO,
|
|
"vo_dga: XF86VidMode returned no screens - using current resolution.\n");
|
|
}
|
|
dga_modenum = j;
|
|
vo_dga_vp_width = mX;
|
|
vo_dga_vp_height = mY;
|
|
}
|
|
|
|
#else
|
|
mp_msg(MSGT_VO, MSGL_INFO,
|
|
"vo_dga: Only have DGA 1.0 extension and no XF86VidMode :-(\n");
|
|
mp_msg(MSGT_VO, MSGL_INFO,
|
|
" Thus, resolution switching is NOT possible.\n");
|
|
|
|
#endif
|
|
#endif
|
|
|
|
vo_dga_src_width = width;
|
|
vo_dga_src_height = height;
|
|
|
|
if (vo_dga_src_width > vo_dga_vp_width ||
|
|
vo_dga_src_height > vo_dga_vp_height)
|
|
{
|
|
mp_msg(MSGT_VO, MSGL_ERR,
|
|
"vo_dga: Sorry, video larger than viewport is not yet supported!\n");
|
|
// ugly, do something nicer in the future ...
|
|
#ifndef CONFIG_DGA2
|
|
#ifdef CONFIG_XF86VM
|
|
if (vo_dga_vidmodes)
|
|
{
|
|
XFree(vo_dga_vidmodes);
|
|
vo_dga_vidmodes = NULL;
|
|
}
|
|
#endif
|
|
#endif
|
|
return 1;
|
|
}
|
|
|
|
if (vo_dga_vp_width == VO_DGA_INVALID_RES)
|
|
{
|
|
mp_msg(MSGT_VO, MSGL_ERR,
|
|
"vo_dga: Something is wrong with your DGA. There doesn't seem to be a\n"
|
|
" single suitable mode!\n"
|
|
" Please file a bug report (see DOCS/HTML/en/bugreports.html)\n");
|
|
#ifndef CONFIG_DGA2
|
|
#ifdef CONFIG_XF86VM
|
|
if (vo_dga_vidmodes)
|
|
{
|
|
XFree(vo_dga_vidmodes);
|
|
vo_dga_vidmodes = NULL;
|
|
}
|
|
#endif
|
|
#endif
|
|
return 1;
|
|
}
|
|
// now let's start the DGA thing
|
|
|
|
if (!vo_config_count || width != prev_width || height != prev_height)
|
|
{
|
|
#ifdef CONFIG_DGA2
|
|
|
|
if (!XDGAOpenFramebuffer(mDisplay, mScreen))
|
|
{
|
|
mp_msg(MSGT_VO, MSGL_ERR,
|
|
"vo_dga: Framebuffer mapping failed!!!\n");
|
|
return 1;
|
|
}
|
|
|
|
dgadevice = XDGASetMode(mDisplay, mScreen, dga_modenum);
|
|
XDGASync(mDisplay, mScreen);
|
|
|
|
vo_dga_base = dgadevice->data;
|
|
XFree(dgadevice);
|
|
|
|
XDGASetViewport(mDisplay, mScreen, 0, 0, XDGAFlipRetrace);
|
|
|
|
#else
|
|
|
|
#ifdef CONFIG_XF86VM
|
|
if (have_vm)
|
|
{
|
|
XF86VidModeLockModeSwitch(mDisplay, mScreen, 0);
|
|
// Two calls are needed to switch modes on my ATI Rage 128. Why?
|
|
// for riva128 one call is enough!
|
|
XF86VidModeSwitchToMode(mDisplay, mScreen,
|
|
vo_dga_vidmodes[dga_modenum]);
|
|
XF86VidModeSwitchToMode(mDisplay, mScreen,
|
|
vo_dga_vidmodes[dga_modenum]);
|
|
}
|
|
#endif
|
|
|
|
XF86DGAGetViewPortSize(mDisplay, mScreen,
|
|
&vo_dga_vp_width, &vo_dga_vp_height);
|
|
|
|
XF86DGAGetVideo(mDisplay, mScreen,
|
|
(char **) &vo_dga_base, &vo_dga_width, &bank,
|
|
&ram);
|
|
|
|
XF86DGADirectVideo(mDisplay, mScreen,
|
|
XF86DGADirectGraphics | XF86DGADirectMouse |
|
|
XF86DGADirectKeyb);
|
|
|
|
XF86DGASetViewPort(mDisplay, mScreen, 0, 0);
|
|
|
|
#endif
|
|
}
|
|
// do some more checkings here ...
|
|
|
|
mp_msg(MSGT_VO, MSGL_V,
|
|
"vo_dga: bytes/line: %d, screen res: %dx%d, depth: %d, base: %p, bpp: %d\n",
|
|
vo_dga_width, vo_dga_vp_width, vo_dga_vp_height,
|
|
HW_MODE.vdm_bytespp, vo_dga_base, HW_MODE.vdm_bitspp);
|
|
|
|
x_off = (vo_dga_vp_width - vo_dga_src_width) >> 1;
|
|
y_off = (vo_dga_vp_height - vo_dga_src_height) >> 1;
|
|
|
|
vo_dga_bytes_per_line = vo_dga_src_width * HW_MODE.vdm_bytespp;
|
|
vo_dga_lines = vo_dga_src_height;
|
|
|
|
vo_dga_src_offset = 0;
|
|
vo_dga_vp_offset =
|
|
(y_off * vo_dga_width + x_off) * HW_MODE.vdm_bytespp;
|
|
|
|
vo_dga_vp_skip = (vo_dga_width - vo_dga_src_width) * HW_MODE.vdm_bytespp; // todo
|
|
|
|
mp_msg(MSGT_VO, MSGL_V, "vo_dga: vp_off=%d, vp_skip=%d, bpl=%d\n",
|
|
vo_dga_vp_offset, vo_dga_vp_skip, vo_dga_bytes_per_line);
|
|
|
|
|
|
XGrabKeyboard(mDisplay, DefaultRootWindow(mDisplay), True,
|
|
GrabModeAsync, GrabModeAsync, CurrentTime);
|
|
if (vo_grabpointer)
|
|
XGrabPointer(mDisplay, DefaultRootWindow(mDisplay), True,
|
|
ButtonPressMask, GrabModeAsync, GrabModeAsync,
|
|
None, None, CurrentTime);
|
|
|
|
if (!vo_config_count || width != prev_width || height != prev_height)
|
|
{
|
|
init_video_buffers(vo_dga_base,
|
|
vo_dga_vp_height,
|
|
vo_dga_width * HW_MODE.vdm_bytespp,
|
|
#ifdef CONFIG_DGA2
|
|
modeline->maxViewportY,
|
|
#else
|
|
vo_dga_vp_height,
|
|
#endif
|
|
vo_doublebuffering);
|
|
prev_width = width;
|
|
prev_height = height;
|
|
}
|
|
|
|
mp_msg(MSGT_VO, MSGL_V, "vo_dga: Using %d frame buffer%s.\n",
|
|
vo_dga_nr_video_buffers,
|
|
vo_dga_nr_video_buffers == 1 ? "" : "s");
|
|
|
|
vo_dga_is_running = 1;
|
|
return 0;
|
|
}
|
|
|
|
static int dga_depths_init = 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 CONFIG_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 CONFIG_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 uint32_t get_image(mp_image_t * mpi)
|
|
{
|
|
if (!IMGFMT_IS_BGR(mpi->imgfmt) ||
|
|
(IMGFMT_BGR_DEPTH(mpi->imgfmt) !=
|
|
vo_dga_modes[vo_dga_hw_mode].vdm_mplayer_depth)
|
|
|| (mpi->type == MP_IMGTYPE_STATIC && vo_dga_nr_video_buffers > 1)
|
|
|| (mpi->type == MP_IMGTYPE_IP && vo_dga_nr_video_buffers < 2)
|
|
|| (mpi->type == MP_IMGTYPE_IPB))
|
|
return VO_FALSE;
|
|
|
|
if ((mpi->flags & MP_IMGFLAG_ACCEPT_STRIDE) ||
|
|
(mpi->flags & MP_IMGFLAG_ACCEPT_WIDTH &&
|
|
((vo_dga_bytes_per_line + vo_dga_vp_skip) % (mpi->bpp / 8)) == 0)
|
|
|| (mpi->width * (mpi->bpp / 8) ==
|
|
(vo_dga_bytes_per_line + vo_dga_vp_skip)))
|
|
{
|
|
|
|
mpi->planes[0] = CURRENT_VIDEO_BUFFER.data + vo_dga_vp_offset;
|
|
mpi->stride[0] = vo_dga_bytes_per_line + vo_dga_vp_skip;
|
|
mpi->width =
|
|
(vo_dga_bytes_per_line + vo_dga_vp_skip) / (mpi->bpp / 8);
|
|
mpi->flags |= MP_IMGFLAG_DIRECT;
|
|
return VO_TRUE;
|
|
}
|
|
|
|
return VO_FALSE;
|
|
}
|
|
|
|
static int control(uint32_t request, void *data)
|
|
{
|
|
switch (request)
|
|
{
|
|
case VOCTRL_GET_IMAGE:
|
|
return get_image(data);
|
|
case VOCTRL_QUERY_FORMAT:
|
|
return query_format(*((uint32_t *) data));
|
|
}
|
|
return VO_NOTIMPL;
|
|
}
|
|
|
|
//---------------------------------------------------------
|