Mercurial > mplayer.hg
view libvo/vo_dga.c @ 36767:18428293fb7f
spudec: fix spudec_apply_palette_crop return value.
| author | reimar |
|---|---|
| date | Sun, 16 Feb 2014 16:30:01 +0000 |
| parents | 5d3f93051de9 |
| children |
line wrap: on
line source
/* * 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" #define NO_DRAW_SLICE #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/xf86dga.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; int bpp = pixel_stride(vo_dga_src_format); vo_draw_alpha_func draw = vo_get_draw_alpha(vo_dga_src_format); offset = vo_dga_width * y0 + x0; buffer_stride = vo_dga_width * bpp; d = CURRENT_VIDEO_BUFFER.data + vo_dga_vp_offset; d += bpp * offset; if (draw) draw(w, h, src, srca, stride, d, buffer_stride); } //--------------------------------------------------------- // 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 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; } //---------------------------------------------------------