changeset 23985:140cf1a3a7d6

Forgot to add the main vo_xvr100.c file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libvo/vo_xvr100.c	Fri Aug 03 17:14:38 2007 +0000
@@ -0,0 +1,451 @@
+/*
+ * SUN XVR-100 (ATI Radeon 7000) VO driver for SPARC Solaris(at least)
+ *
+ * Copyright (C) 2000-2004 Robin Kay <komadori [at] gekkou [dot] co [dot] uk>
+ * Copyright (C) 2004 Jake Goerzen
+ * Copyright (C) 2007 Denes Balatoni
+ *
+ * written for xine by
+ * Robin Kay <komadori [at] gekkou [dot] co [dot] uk>
+ *
+ * Sun XVR-100 framebuffer graciously donated by Jake Goerzen.
+ *
+ * Ported to mplayer by Denes Balatoni
+ * Contains portions from the mga and tdfix_vid vo drivers
+ *
+ * no double-buffering, as it would slow down playback (waiting for vertical retraces)
+ * FIXME: only YV12 supported for now
+ *
+ * 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 <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/fbio.h>
+#include <sys/visual_io.h>
+#include <strings.h>
+#include <sys/mman.h>
+
+#include "config.h"
+#include "video_out.h"
+#include "video_out_internal.h"
+#include "aspect.h"
+#include "geometry.h"
+#include "fastmemcpy.h"
+#include "mp_msg.h"
+
+
+static vo_info_t info = {
+    "sun xvr-100",
+    "xvr100",
+    "Denes Balatoni",
+    ""
+};
+
+LIBVO_EXTERN(xvr100)
+
+#define PFB_VRAM_MMAPBASE 0x08000000
+#define PFB_VRAM_MMAPLEN 0x04000000 /* depends on memory size */
+#define PFB_REGS_MMAPBASE 0x10000000
+#define PFB_REGS_MMAPLEN 0x00040000
+
+#define PFB_CLOCK_CNTL_INDEX 0x002
+#define PFB_CLOCK_CNTL_DATA 0x003
+
+#define PFB_MC_FB_LOCATION 0x052
+
+#define PFB_OV0_Y_X_START 0x100
+#define PFB_OV0_Y_X_END 0x101
+#define PFB_OV0_REG_LOAD_CNTL 0x104
+#define PFB_OV0_REG_LOAD_LOCK 0x00000001
+#define PFB_OV0_REG_LOAD_LOCK_READBACK 0x00000008
+#define PFB_OV0_SCALE_CNTL 0x108
+#define PFB_OV0_SCALE_EN 0x417f0000/*417f0000*/
+#define PFB_OV0_SCALE_YUV12 0x00000A00
+#define PFB_OV0_SCALE_VYUY422 0x00000B00
+#define PFB_OV0_V_INC 0x109
+#define PFB_OV0_P1_V_ACCUM_INIT 0x10A
+#define PFB_OV0_P23_V_ACCUM_INIT 0x10B
+#define PFB_OV0_P1_BLANK_LINES_AT_TOP 0x10C
+#define PFB_OV0_P23_BLANK_LINES_AT_TOP 0x10D
+#define PFB_OV0_BASE_ADDR 0x10F
+#define PFB_OV0_BUF0_BASE_ADRS 0x110
+#define PFB_OV0_BUF1_BASE_ADRS 0x111
+#define PFB_OV0_BUF2_BASE_ADRS 0x112
+#define PFB_OV0_BUF3_BASE_ADRS 0x113
+#define PFB_OV0_BUF4_BASE_ADRS 0x114
+#define PFB_OV0_BUF5_BASE_ADRS 0x115
+#define PFB_OV0_VID_BUF_PITCH0_VALUE 0x118
+#define PFB_OV0_VID_BUF_PITCH1_VALUE 0x119
+#define PFB_OV0_AUTO_FLIP_CNTL 0x11C
+#define PFB_OV0_AUTO_FLIP_BUF0 0x00000200
+#define PFB_OV0_AUTO_FLIP_BUF3 0x00000243
+#define PFB_OV0_DEINTERLACE_PATTERN 0x11D
+#define PFB_OV0_H_INC 0x120
+#define PFB_OV0_STEP_BY 0x121
+#define PFB_OV0_P1_H_ACCUM_INIT 0x122
+#define PFB_OV0_P23_H_ACCUM_INIT 0x123
+#define PFB_OV0_P1_X_START_END 0x125
+#define PFB_OV0_P2_X_START_END 0x126
+#define PFB_OV0_P3_X_START_END 0x127
+#define PFB_OV0_FILTER_CNTL 0x128
+#define PFB_OV0_FILTER_EN 0x0000000f
+#define PFB_OV0_GRPH_KEY_CLR_LOW 0x13B
+#define PFB_OV0_GRPH_KEY_CLR_HIGH 0x13C
+#define PFB_OV0_KEY_CNTL 0x13D
+#define PFB_OV0_KEY_EN 0x00000121
+
+#define PFB_DISP_MERGE_CNTL 0x358
+#define PFB_DISP_MERGE_EN 0xffff0000
+
+
+
+static char pfb_devname[]="/dev/fbs/pfb0";
+static int pfb_devfd;
+static uint8_t *pfb_vbase;
+static volatile uint32_t *pfb_vregs;
+static int pfb_buffer[3];
+static int pfb_stride[3];
+static int pfb_srcwidth, pfb_srcheight, pfb_dstwidth, pfb_dstheight;
+static int pfb_native_format=PFB_OV0_SCALE_YUV12;
+static int pfb_deinterlace_en=0;
+static short int pfb_wx0, pfb_wy0, pfb_wx1, pfb_wy1;
+static int pfb_xres,pfb_yres;
+static int pfb_free_top;
+static int pfb_fs;
+static int pfb_usecolorkey=0;
+static uint32_t pfb_colorkey;
+
+
+
+void pfb_overlay_on() {
+    int i, h_inc, h_step, ecp_div;
+
+    pfb_vregs[PFB_CLOCK_CNTL_INDEX] = (pfb_vregs[PFB_CLOCK_CNTL_INDEX] & ~0x0000003f) | 0x00000008;
+    ecp_div = (pfb_vregs[PFB_CLOCK_CNTL_DATA] >> 8) & 0x3;
+    h_inc = (pfb_srcwidth << (12 + ecp_div)) / pfb_dstwidth;
+    h_step = 1;
+
+    while (h_inc > 0x1fff) {
+        h_inc >>= 1;
+        h_step++;
+    }
+
+    pfb_vregs[PFB_OV0_REG_LOAD_CNTL] = PFB_OV0_REG_LOAD_LOCK;
+    while (!(pfb_vregs[PFB_OV0_REG_LOAD_CNTL] & PFB_OV0_REG_LOAD_LOCK_READBACK))
+        usleep(100);
+
+    pfb_vregs[PFB_DISP_MERGE_CNTL] = PFB_DISP_MERGE_EN;
+    pfb_vregs[PFB_OV0_Y_X_START] = (pfb_wy0 << 16) | pfb_wx0;
+    pfb_vregs[PFB_OV0_Y_X_END] = ((pfb_wy1 - 1) << 16) | (pfb_wx1 - 1);
+    pfb_vregs[PFB_OV0_V_INC] = ((pfb_deinterlace_en ? pfb_srcheight/2 : pfb_srcheight) << 20) / pfb_dstheight;
+    pfb_vregs[PFB_OV0_P1_V_ACCUM_INIT] = 0x00180001;
+    pfb_vregs[PFB_OV0_P23_V_ACCUM_INIT] = 0x00180001;
+    pfb_vregs[PFB_OV0_P1_BLANK_LINES_AT_TOP] = (((pfb_deinterlace_en ? pfb_srcheight/2 : pfb_srcheight) - 1) << 16) | 0xfff;
+    pfb_vregs[PFB_OV0_P23_BLANK_LINES_AT_TOP] = (((pfb_deinterlace_en ? pfb_srcheight/2 : pfb_srcheight) / 2 - 1) << 16) | 0x7ff;
+    pfb_vregs[PFB_OV0_BASE_ADDR] = (pfb_vregs[PFB_MC_FB_LOCATION] & 0xffff) << 16;
+    pfb_vregs[PFB_OV0_VID_BUF_PITCH0_VALUE] = pfb_deinterlace_en ? pfb_stride[0]*2 : pfb_stride[0];
+    pfb_vregs[PFB_OV0_VID_BUF_PITCH1_VALUE] = pfb_deinterlace_en ? pfb_stride[1]*2 : pfb_stride[1];
+    pfb_vregs[PFB_OV0_DEINTERLACE_PATTERN] = 0x000aaaaa;
+    pfb_vregs[PFB_OV0_H_INC] = ((h_inc / 2) << 16) | h_inc;
+    pfb_vregs[PFB_OV0_STEP_BY] = (h_step << 8) | h_step;
+    pfb_vregs[PFB_OV0_P1_H_ACCUM_INIT] = (((0x00005000 + h_inc) << 7) & 0x000f8000) | (((0x00005000 + h_inc) << 15) & 0xf0000000);
+    pfb_vregs[PFB_OV0_P23_H_ACCUM_INIT] = (((0x0000A000 + h_inc) << 6) & 0x000f8000) | (((0x0000A000 + h_inc) << 14) & 0x70000000);
+    pfb_vregs[PFB_OV0_P1_X_START_END] = pfb_srcwidth - 1;
+    pfb_vregs[PFB_OV0_P2_X_START_END] = (pfb_srcwidth / 2) - 1;
+    pfb_vregs[PFB_OV0_P3_X_START_END] = (pfb_srcwidth / 2) - 1;
+    pfb_vregs[PFB_OV0_FILTER_CNTL] = PFB_OV0_FILTER_EN;
+
+    if (pfb_usecolorkey) {
+        pfb_vregs[PFB_OV0_GRPH_KEY_CLR_LOW] = pfb_colorkey;
+        pfb_vregs[PFB_OV0_GRPH_KEY_CLR_HIGH] = pfb_colorkey | 0xff000000;
+        pfb_vregs[PFB_OV0_KEY_CNTL] = PFB_OV0_KEY_EN;
+    } else {
+        pfb_vregs[PFB_OV0_KEY_CNTL] = 0x010;
+    }
+
+    pfb_vregs[PFB_OV0_SCALE_CNTL] = PFB_OV0_SCALE_EN | pfb_native_format;
+
+    pfb_vregs[PFB_OV0_REG_LOAD_CNTL] = 0;
+
+    pfb_vregs[PFB_OV0_BUF0_BASE_ADRS] = pfb_buffer[0];
+    pfb_vregs[PFB_OV0_BUF1_BASE_ADRS] = pfb_buffer[1] | 0x00000001;
+    pfb_vregs[PFB_OV0_BUF2_BASE_ADRS] = pfb_buffer[2] | 0x00000001;
+
+    pfb_vregs[PFB_OV0_AUTO_FLIP_CNTL] = PFB_OV0_AUTO_FLIP_BUF0;
+}
+
+void pfb_overlay_off() {
+    pfb_vregs[PFB_OV0_SCALE_CNTL] = 0;
+}
+
+void center_overlay() {
+    if (pfb_xres > pfb_dstwidth) {
+        pfb_wx0 = (pfb_xres - pfb_dstwidth) / 2;
+        pfb_wx1 = pfb_wx0 + pfb_dstwidth;
+    }
+    else {
+        pfb_wx0 = 0;
+        pfb_wx1 = pfb_xres;
+    }
+
+    if (pfb_yres > pfb_dstheight) {
+        pfb_wy0 = (pfb_yres - pfb_dstheight) / 2;
+        pfb_wy1 = pfb_wy0 + pfb_dstheight;
+    }
+    else {
+        pfb_wy0 = 0;
+        pfb_wy1 = pfb_yres;
+    }
+}
+
+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 memsize;
+
+    pfb_srcwidth=width;
+    pfb_srcheight=height;
+
+    if (pfb_srcwidth>1536)
+        mp_msg(MSGT_VO, MSGL_WARN, "vo_xvr100: XVR-100 can not handle width greater than 1536 pixels!\n");
+
+    if (!(flags & VOFLAG_XOVERLAY_SUB_VO)) {
+        aspect_save_orig(width,height);
+        aspect_save_prescale(d_width,d_height);
+        aspect_save_screenres(pfb_xres,pfb_yres);
+        if( flags&VOFLAG_FULLSCREEN) { /* -fs */
+            aspect(&pfb_dstwidth,&pfb_dstheight, A_ZOOM);
+            pfb_fs = 1;
+        } else {
+            aspect(&pfb_dstwidth,&pfb_dstheight, A_NOZOOM);
+            pfb_fs = 0;
+        }
+    } else {
+        pfb_dstwidth=d_width;
+        pfb_dstheight=d_height;
+    }
+
+    center_overlay();
+
+    pfb_stride[0]=(pfb_srcwidth+15) & ~15;
+    pfb_stride[1]=pfb_stride[2]=(((pfb_srcwidth+1)>>1)+15) & ~15;
+    memsize = (pfb_stride[0]*pfb_srcheight+pfb_stride[1]*((pfb_srcheight+1) & ~1));
+    if (memsize > pfb_free_top) {
+        mp_msg(MSGT_VO, MSGL_FATAL, "vo_xvr100: out of VRAM! \n");
+        return 1;
+    }
+    pfb_buffer[0] = pfb_free_top - memsize;
+    pfb_buffer[1] = pfb_buffer[0] + pfb_stride[0]*pfb_srcheight;
+    pfb_buffer[2] = pfb_buffer[1] + pfb_stride[1]*((pfb_srcheight+1)>>1);
+
+    pfb_overlay_on();
+
+    return 0;
+}
+
+static int preinit(const char *arg) {
+    struct vis_identifier ident;
+    struct fbgattr attr;
+
+    if ((pfb_devfd = open(pfb_devname, O_RDWR)) < 0) {
+        mp_msg(MSGT_VO, MSGL_ERR, "vo_xvr100: Error: can't open framebuffer device '%s'\n", pfb_devname);
+        return 1;
+    }
+
+    if (ioctl(pfb_devfd, VIS_GETIDENTIFIER, &ident) < 0) {
+        mp_msg(MSGT_VO, MSGL_ERR, "vo_xvr100: Error: ioctl failed (VIS_GETIDENTIFIER), bad device (%s)\n", pfb_devname);
+        return 1;
+    }
+
+    if (strcmp("SUNWpfb", ident.name) == 0) {
+        mp_msg(MSGT_VO, MSGL_INFO, "vo_xvr100: SUNWpfb (XVR-100/ATI Radeon 7000) detected \n");
+    }
+    else {
+        mp_msg(MSGT_VO, MSGL_ERR, "vo_xvr100: Error: '%s' is not a SUN XVR-100 framebuffer device\n", pfb_devname);
+        return 1;
+    }
+
+    if (ioctl(pfb_devfd, FBIOGATTR, &attr) < 0) {
+        mp_msg(MSGT_VO, MSGL_ERR, "vo_xvr100: Error: ioctl failed (FBIOGATTR)\n");
+        close(pfb_devfd);
+        return 1;
+    }
+
+    pfb_free_top = attr.fbtype.fb_size - 0x2000;
+    pfb_xres = attr.fbtype.fb_width;
+    pfb_yres = attr.fbtype.fb_height;
+
+    if ((pfb_vbase = mmap(NULL, PFB_VRAM_MMAPLEN, PROT_READ | PROT_WRITE,
+                          MAP_SHARED, pfb_devfd, PFB_VRAM_MMAPBASE)) == MAP_FAILED) {
+        mp_msg(MSGT_VO, MSGL_ERR, "vo_xvr100: Error: unable to memory map framebuffer\n");
+        close(pfb_devfd);
+        return 1;
+    }
+
+    if ((pfb_vregs = (uint32_t *)(void *)mmap(NULL, PFB_REGS_MMAPLEN, PROT_READ | PROT_WRITE,
+                                              MAP_SHARED, pfb_devfd, PFB_REGS_MMAPBASE)) == MAP_FAILED) {
+        mp_msg(MSGT_VO, MSGL_ERR, "vo_xvr100: Error: unable to memory map framebuffer\n");
+        munmap(pfb_vbase, PFB_VRAM_MMAPLEN);
+        close(pfb_devfd);
+        return 1;
+    }
+
+  return 0;
+}
+
+static void uninit(void)
+{
+    if (!vo_config_count)
+        return;
+
+    pfb_overlay_off();
+    munmap(pfb_vbase, PFB_VRAM_MMAPLEN);
+    munmap(pfb_vregs, PFB_REGS_MMAPLEN);
+}
+
+static uint32_t pfb_fullscreen() {
+    if (!pfb_fs) {
+        aspect(&pfb_dstwidth,&pfb_dstheight, A_ZOOM);
+        pfb_fs = 1;
+    } else {
+        aspect(&pfb_dstwidth,&pfb_dstheight, A_NOZOOM);
+        pfb_fs = 0;
+    }
+
+    center_overlay();
+
+    pfb_overlay_on();
+
+    return VO_TRUE;
+}
+
+static void draw_alpha(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride){
+    vo_draw_alpha_yv12(w,h,src,srca,stride,pfb_vbase+pfb_buffer[0]+pfb_stride[0]*y0+x0,pfb_stride[0]);
+}
+
+static void draw_osd(void)
+{
+    vo_draw_text(pfb_srcwidth, pfb_srcheight,draw_alpha);
+}
+
+static void check_events(void)
+{
+}
+
+static void flip_page(void)
+{
+}
+
+static uint32_t get_image(mp_image_t *mpi){
+    if (mpi->flags&MP_IMGFLAG_READABLE) return VO_FALSE;
+    if (!(mpi->flags&MP_IMGFLAG_PLANAR)) return VO_FALSE; // FIXME: impossible for YV12, right?
+    if (!(mpi->flags&MP_IMGFLAG_ACCEPT_STRIDE)) return VO_FALSE;
+
+    mpi->planes[0]=pfb_vbase + pfb_buffer[0];
+    mpi->planes[1]=pfb_vbase + pfb_buffer[1];
+    mpi->planes[2]=pfb_vbase + pfb_buffer[2];
+    mpi->stride[0]=pfb_stride[0];
+    mpi->stride[1]=mpi->stride[2]=pfb_stride[1];
+    mpi->flags|=MP_IMGFLAG_DIRECT;
+
+    return VO_TRUE;
+}
+
+static int draw_frame(uint8_t *src[])
+{
+    mp_msg(MSGT_VO,MSGL_WARN,"!!! vo_xvr100::draw_frame() called !!!\n");
+    return 0;
+}
+
+
+static int draw_slice(uint8_t *src[], int stride[], int w,int h,int x,int y)
+{
+    mem2agpcpy_pic(pfb_vbase + pfb_buffer[0] + pfb_stride[0] * y + x, src[0], w, h, pfb_stride[0], stride[0]);
+    w>>=1; h>>=1; x>>=1; y>>=1;
+    mem2agpcpy_pic(pfb_vbase + pfb_buffer[1] + pfb_stride[1] * y + x, src[1], w, h, pfb_stride[1], stride[1]);
+    mem2agpcpy_pic(pfb_vbase + pfb_buffer[2] + pfb_stride[1] * y + x, src[2], w, h, pfb_stride[1], stride[2]);
+
+    return 0;
+}
+
+
+static uint32_t draw_image(mp_image_t *mpi){
+    // if -dr or -slices then do nothing:
+    if (mpi->flags&(MP_IMGFLAG_DIRECT|MP_IMGFLAG_DRAW_CALLBACK)) return VO_TRUE;
+
+    draw_slice(mpi->planes,mpi->stride,mpi->w,mpi->h,0,0);
+
+    return VO_TRUE;
+}
+
+static uint32_t pfb_set_colorkey(mp_colorkey_t* colork) {
+    pfb_colorkey = colork->x11;
+    pfb_usecolorkey = 1;
+
+    pfb_overlay_on();
+
+    return VO_TRUE;
+}
+
+static uint32_t pfb_set_window(mp_win_t* w) {
+    pfb_dstwidth = w->w;
+    pfb_dstheight = w->h;
+    pfb_wx0 = w->x;
+    pfb_wy0 = w->y;
+    pfb_wx1 = w->x + pfb_dstwidth;
+    pfb_wy1 = w->y + pfb_dstheight;
+
+    pfb_overlay_on();
+
+    return VO_TRUE;
+}
+
+static int query_format(uint32_t format)
+{
+    switch(format){
+    case IMGFMT_YV12:
+    case IMGFMT_I420:
+        return VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW |VFCAP_HWSCALE_UP|VFCAP_HWSCALE_DOWN|VFCAP_ACCEPT_STRIDE;
+    }
+    return 0;
+}
+
+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));
+        case VOCTRL_DRAW_IMAGE:
+            return draw_image(data);
+        case VOCTRL_FULLSCREEN:
+            return pfb_fullscreen();
+        case VOCTRL_XOVERLAY_SUPPORT:
+            return VO_TRUE;
+        case VOCTRL_XOVERLAY_SET_COLORKEY:
+            return pfb_set_colorkey(data);
+        case VOCTRL_XOVERLAY_SET_WIN:
+            return pfb_set_window(data);
+    }
+
+    return VO_NOTIMPL;
+}