libvo/vosub_vidix.c

   1 /*
   2  *  vosub_vidix.c
   3  *
   4  *      Copyright (C) Nick Kurshev <nickols_k@mail.ru> - 2002
   5  *      Copyright (C) Alex Beregszaszi
   6  *
   7  *  You can redistribute this file under terms and conditions
   8  *  of GNU General Public licence v2 or later.
   9  *
  10  * This file contains vidix interface to any mplayer's VO plugin.
  11  * (Partly based on vesa_lvo.c from mplayer's package)
  12  */
  13
  14 #include <inttypes.h>
  15 #include <unistd.h>
  16 #include <fcntl.h>
  17 #ifndef __MINGW32__
  18 #include <sys/ioctl.h>
  19 #include <sys/mman.h>
  20 #endif
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <errno.h>
  25
  26 #include "config.h"
  27 #include "mp_msg.h"
  28 #include "help_mp.h"
  29
  30 #include "vidix/vidixlib.h"
  31 #include "fastmemcpy.h"
  32 #include "osd.h"
  33 #include "video_out.h"
  34 #include "sub.h"
  35 #include "vosub_vidix.h"
  36
  37 #include "libmpcodecs/vfcap.h"
  38 #include "libmpcodecs/mp_image.h"
  39
  40 #define NUM_FRAMES VID_PLAY_MAXFRAMES /* Temporary: driver will overwrite it */
  41
  42 static VDL_HANDLE vidix_handler = NULL;
  43 static uint8_t *vidix_mem = NULL;
  44 static uint8_t next_frame;
  45 static unsigned image_Bpp,image_height,image_width,src_format,forced_fourcc=0;
  46 static int video_on=0;
  47
  48 static vidix_capability_t vidix_cap;
  49 static vidix_playback_t   vidix_play;
  50 static vidix_fourcc_t     vidix_fourcc;
  51 static vo_functions_t *   vo_server;
  52 static vidix_yuv_t        dstrides;
  53 /*static uint32_t (*server_control)(uint32_t request, void *data, ...);*/
  54
  55 int vidix_start(void)
  56 {
  57     int err;
  58     if((err=vdlPlaybackOn(vidix_handler))!=0)
  59     {
  60         mp_msg(MSGT_VO,MSGL_ERR, MSGTR_LIBVO_SUB_VIDIX_CantStartPlayback,strerror(err));
  61         return -1;
  62     }
  63     video_on=1;
  64     return 0;
  65 }
  66
  67 int vidix_stop(void)
  68 {
  69     int err;
  70     if((err=vdlPlaybackOff(vidix_handler))!=0)
  71     {
  72         mp_msg(MSGT_VO,MSGL_ERR, MSGTR_LIBVO_SUB_VIDIX_CantStopPlayback,strerror(err));
  73         return -1;
  74     }
  75     video_on=0;
  76     return 0;
  77 }
  78
  79 void vidix_term( void )
  80 {
  81   if( mp_msg_test(MSGT_VO,MSGL_DBG2) ) {
  82     mp_msg(MSGT_VO,MSGL_DBG2, "vosub_vidix: vidix_term() was called\n"); }
  83         vidix_stop();
  84         vdlClose(vidix_handler);
  85 //  vo_server->control=server_control;
  86 }
  87
  88 static uint32_t vidix_draw_slice_420(uint8_t *image[], int stride[], int w,int h,int x,int y)
  89 {
  90     uint8_t *src;
  91     uint8_t *dest;
  92     int i;
  93
  94     /* Plane Y */
  95     dest = vidix_mem + vidix_play.offsets[next_frame] + vidix_play.offset.y;
  96     dest += dstrides.y*y + x;
  97     src = image[0];
  98     for(i=0;i<h;i++){
  99         memcpy(dest,src,w);
 100         src+=stride[0];
 101         dest += dstrides.y;
 102     }
 103
 104     if (vidix_play.flags & VID_PLAY_INTERLEAVED_UV)
 105     {
 106         int hi,wi;
 107         uint8_t *src2;
 108         dest = vidix_mem + vidix_play.offsets[next_frame] + vidix_play.offset.v;
 109         dest += dstrides.y*y/2 + x; // <- is this correct ?
 110         h/=2;
 111         w/=2;
 112         src = image[1];
 113         src2 = image[2];
 114         for(hi = 0; hi < h; hi++)
 115         {
 116             for(wi = 0; wi < w; wi++)
 117             {
 118                 dest[2*wi+0] = src[wi];
 119                 dest[2*wi+1] = src2[wi];
 120             }
 121             dest += dstrides.y;
 122             src += stride[1];
 123             src2+= stride[2];
 124         }
 125     }
 126     else
 127     {
 128                 /* Plane V */
 129                 dest = vidix_mem + vidix_play.offsets[next_frame] + vidix_play.offset.v;
 130                 dest += dstrides.v*y/4 + x;
 131                 src = image[1];
 132                 for(i=0;i<h/2;i++){
 133                         memcpy(dest,src,w/2);
 134                         src+=stride[1];
 135                         dest+=dstrides.v/2;
 136                 }
 137
 138                 /* Plane U */
 139                 dest = vidix_mem + vidix_play.offsets[next_frame] + vidix_play.offset.u;
 140                 dest += dstrides.u*y/4 + x;
 141                 src = image[2];
 142                 for(i=0;i<h/2;i++){
 143                         memcpy(dest,src,w/2);
 144                         src+=stride[2];
 145                         dest += dstrides.u/2;
 146                 }
 147                 return 0;
 148     }
 149     return -1;
 150 }
 151
 152 static uint32_t vidix_draw_slice_410(uint8_t *image[], int stride[], int w,int h,int x,int y)
 153 {
 154     uint8_t *src;
 155     uint8_t *dest;
 156     int i;
 157
 158     /* Plane Y */
 159     dest = vidix_mem + vidix_play.offsets[next_frame] + vidix_play.offset.y;
 160     dest += dstrides.y*y + x;
 161     src = image[0];
 162     for(i=0;i<h;i++){
 163         memcpy(dest,src,w);
 164         src+=stride[0];
 165         dest += dstrides.y;
 166     }
 167
 168     if (vidix_play.flags & VID_PLAY_INTERLEAVED_UV)
 169     {
 170         mp_msg(MSGT_VO,MSGL_WARN, MSGTR_LIBVO_SUB_VIDIX_InterleavedUvForYuv410pNotSupported);
 171     }
 172     else
 173     {
 174                 /* Plane V */
 175                 dest = vidix_mem + vidix_play.offsets[next_frame] + vidix_play.offset.v;
 176                 dest += dstrides.v*y/8 + x;
 177                 src = image[1];
 178                 for(i=0;i<h/4;i++){
 179                         memcpy(dest,src,w/4);
 180                         src+=stride[1];
 181                         dest+=dstrides.v/4;
 182                 }
 183
 184                 /* Plane U */
 185                 dest = vidix_mem + vidix_play.offsets[next_frame] + vidix_play.offset.u;
 186                 dest += dstrides.u*y/8 + x;
 187                 src = image[2];
 188                 for(i=0;i<h/4;i++){
 189                         memcpy(dest,src,w/4);
 190                         src+=stride[2];
 191                         dest += dstrides.u/4;
 192                 }
 193                 return 0;
 194     }
 195     return -1;
 196 }
 197
 198 static uint32_t vidix_draw_slice_packed(uint8_t *image[], int stride[], int w,int h,int x,int y)
 199 {
 200     uint8_t *src;
 201     uint8_t *dest;
 202     int i;
 203
 204     dest = vidix_mem + vidix_play.offsets[next_frame] + vidix_play.offset.y;
 205     dest += dstrides.y*y + x;
 206     src = image[0];
 207     for(i=0;i<h;i++){
 208         memcpy(dest,src,w*image_Bpp);
 209         src+=stride[0];
 210         dest += dstrides.y;
 211     }
 212     return 0;
 213 }
 214
 215 uint32_t vidix_draw_slice(uint8_t *image[], int stride[], int w,int h,int x,int y)
 216 {
 217     mp_msg(MSGT_VO,MSGL_WARN, MSGTR_LIBVO_SUB_VIDIX_DummyVidixdrawsliceWasCalled);
 218     return -1;
 219 }
 220
 221 static uint32_t  vidix_draw_image(mp_image_t *mpi){
 222     if( mp_msg_test(MSGT_VO,MSGL_DBG2) ) {
 223       mp_msg(MSGT_VO,MSGL_DBG2, "vosub_vidix: vidix_draw_image() was called\n"); }
 224
 225     // if -dr or -slices then do nothing:
 226     if(mpi->flags&(MP_IMGFLAG_DIRECT|MP_IMGFLAG_DRAW_CALLBACK)) return VO_TRUE;
 227
 228     vo_server->draw_slice(mpi->planes,mpi->stride,
 229         vidix_play.src.w,vidix_play.src.h,vidix_play.src.x,vidix_play.src.y);
 230     return VO_TRUE;
 231 }
 232
 233 uint32_t vidix_draw_frame(uint8_t *image[])
 234 {
 235   mp_msg(MSGT_VO,MSGL_WARN, MSGTR_LIBVO_SUB_VIDIX_DummyVidixdrawframeWasCalled);
 236   return -1;
 237 }
 238
 239 void     vidix_flip_page(void)
 240 {
 241   if( mp_msg_test(MSGT_VO,MSGL_DBG2) ) {
 242     mp_msg(MSGT_VO,MSGL_DBG2, "vosub_vidix: vidix_flip_page() was called\n"); }
 243   if(vo_doublebuffering)
 244   {
 245         vdlPlaybackFrameSelect(vidix_handler,next_frame);
 246         next_frame=(next_frame+1)%vidix_play.num_frames;
 247   }
 248 }
 249
 250 static void draw_alpha(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride)
 251 {
 252     uint32_t apitch,bespitch;
 253     char *lvo_mem;
 254     lvo_mem = vidix_mem + vidix_play.offsets[next_frame] + vidix_play.offset.y;
 255     apitch = vidix_play.dest.pitch.y-1;
 256     switch(vidix_play.fourcc){
 257     case IMGFMT_YV12:
 258     case IMGFMT_IYUV:
 259     case IMGFMT_I420:
 260     case IMGFMT_YVU9:
 261     case IMGFMT_IF09:
 262     case IMGFMT_Y8:
 263     case IMGFMT_Y800:
 264         bespitch = (vidix_play.src.w + apitch) & (~apitch);
 265         vo_draw_alpha_yv12(w,h,src,srca,stride,lvo_mem+bespitch*y0+x0,bespitch);
 266         break;
 267     case IMGFMT_YUY2:
 268         bespitch = (vidix_play.src.w*2 + apitch) & (~apitch);
 269         vo_draw_alpha_yuy2(w,h,src,srca,stride,lvo_mem+bespitch*y0+2*x0,bespitch);
 270         break;
 271     case IMGFMT_UYVY:
 272         bespitch = (vidix_play.src.w*2 + apitch) & (~apitch);
 273         vo_draw_alpha_yuy2(w,h,src,srca,stride,lvo_mem+bespitch*y0+2*x0+1,bespitch);
 274         break;
 275     case IMGFMT_RGB32:
 276     case IMGFMT_BGR32:
 277         bespitch = (vidix_play.src.w*4 + apitch) & (~apitch);
 278         vo_draw_alpha_rgb32(w,h,src,srca,stride,lvo_mem+y0*bespitch+4*x0,bespitch);
 279         break;
 280     case IMGFMT_RGB24:
 281     case IMGFMT_BGR24:
 282         bespitch = (vidix_play.src.w*3 + apitch) & (~apitch);
 283         vo_draw_alpha_rgb24(w,h,src,srca,stride,lvo_mem+y0*bespitch+3*x0,bespitch);
 284         break;
 285     case IMGFMT_RGB16:
 286     case IMGFMT_BGR16:
 287         bespitch = (vidix_play.src.w*2 + apitch) & (~apitch);
 288         vo_draw_alpha_rgb16(w,h,src,srca,stride,lvo_mem+y0*bespitch+2*x0,bespitch);
 289         break;
 290     case IMGFMT_RGB15:
 291     case IMGFMT_BGR15:
 292         bespitch = (vidix_play.src.w*2 + apitch) & (~apitch);
 293         vo_draw_alpha_rgb15(w,h,src,srca,stride,lvo_mem+y0*bespitch+2*x0,bespitch);
 294         break;
 295     default:
 296         return;
 297     }
 298 }
 299
 300 void     vidix_draw_osd(void)
 301 {
 302   if( mp_msg_test(MSGT_VO,MSGL_DBG2) ) {
 303     mp_msg(MSGT_VO,MSGL_DBG2, "vosub_vidix: vidix_draw_osd() was called\n"); }
 304   /* TODO: hw support */
 305   vo_draw_text(vidix_play.src.w,vidix_play.src.h,draw_alpha);
 306 }
 307
 308 uint32_t vidix_query_fourcc(uint32_t format)
 309 {
 310   if( mp_msg_test(MSGT_VO,MSGL_DBG2) ) {
 311     mp_msg(MSGT_VO,MSGL_DBG2, "vosub_vidix: query_format was called: %x (%s)\n",format,vo_format_name(format)); }
 312   vidix_fourcc.fourcc = format;
 313   vdlQueryFourcc(vidix_handler,&vidix_fourcc);
 314   if (vidix_fourcc.depth == VID_DEPTH_NONE)
 315     return 0;
 316   return VFCAP_CSP_SUPPORTED|VFCAP_CSP_SUPPORTED_BY_HW|VFCAP_HWSCALE_UP|VFCAP_HWSCALE_DOWN|VFCAP_OSD|VFCAP_ACCEPT_STRIDE;
 317 }
 318
 319 int vidix_grkey_support(void)
 320 {
 321     return(vidix_fourcc.flags & VID_CAP_COLORKEY);
 322 }
 323
 324 int vidix_grkey_get(vidix_grkey_t *gr_key)
 325 {
 326     return(vdlGetGrKeys(vidix_handler, gr_key));
 327 }
 328
 329 int vidix_grkey_set(const vidix_grkey_t *gr_key)
 330 {
 331     return(vdlSetGrKeys(vidix_handler, gr_key));
 332 }
 333
 334
 335 static int is_422_planes_eq=0;
 336 int      vidix_init(unsigned src_width,unsigned src_height,
 337                    unsigned x_org,unsigned y_org,unsigned dst_width,
 338                    unsigned dst_height,unsigned format,unsigned dest_bpp,
 339                    unsigned vid_w,unsigned vid_h)
 340 {
 341   void *tmp, *tmpa;
 342   size_t i;
 343   int err;
 344   uint32_t sstride,apitch;
 345   if( mp_msg_test(MSGT_VO,MSGL_DBG2) )
 346      mp_msg(MSGT_VO,MSGL_DBG2, "vosub_vidix: vidix_init() was called\n"
 347             "src_w=%u src_h=%u dest_x_y_w_h = %u %u %u %u\n"
 348             "format=%s dest_bpp=%u vid_w=%u vid_h=%u\n"
 349             ,src_width,src_height,x_org,y_org,dst_width,dst_height
 350             ,vo_format_name(format),dest_bpp,vid_w,vid_h);
 351
 352         if(vidix_query_fourcc(format) == 0)
 353         {
 354           mp_msg(MSGT_VO,MSGL_ERR, MSGTR_LIBVO_SUB_VIDIX_UnsupportedFourccForThisVidixDriver,
 355             format,vo_format_name(format));
 356           return -1;
 357         }
 358
 359         if(((vidix_cap.maxwidth != -1) && (vid_w > vidix_cap.maxwidth)) ||
 360             ((vidix_cap.minwidth != -1) && (vid_w < vidix_cap.minwidth)) ||
 361             ((vidix_cap.maxheight != -1) && (vid_h > vidix_cap.maxheight)) ||
 362             ((vidix_cap.minwidth != -1 ) && (vid_h < vidix_cap.minheight)))
 363         {
 364           mp_msg(MSGT_VO,MSGL_ERR, MSGTR_LIBVO_SUB_VIDIX_VideoServerHasUnsupportedResolution,
 365             vid_w, vid_h, vidix_cap.minwidth, vidix_cap.minheight,
 366             vidix_cap.maxwidth, vidix_cap.maxheight);
 367           return -1;
 368         }
 369
 370         err = 0;
 371         switch(dest_bpp)
 372         {
 373           case 1: err = ((vidix_fourcc.depth & VID_DEPTH_1BPP) != VID_DEPTH_1BPP); break;
 374           case 2: err = ((vidix_fourcc.depth & VID_DEPTH_2BPP) != VID_DEPTH_2BPP); break;
 375           case 4: err = ((vidix_fourcc.depth & VID_DEPTH_4BPP) != VID_DEPTH_4BPP); break;
 376           case 8: err = ((vidix_fourcc.depth & VID_DEPTH_8BPP) != VID_DEPTH_8BPP); break;
 377           case 12:err = ((vidix_fourcc.depth & VID_DEPTH_12BPP) != VID_DEPTH_12BPP); break;
 378           case 15:err = ((vidix_fourcc.depth & VID_DEPTH_15BPP) != VID_DEPTH_15BPP); break;
 379           case 16:err = ((vidix_fourcc.depth & VID_DEPTH_16BPP) != VID_DEPTH_16BPP); break;
 380           case 24:err = ((vidix_fourcc.depth & VID_DEPTH_24BPP) != VID_DEPTH_24BPP); break;
 381           case 32:err = ((vidix_fourcc.depth & VID_DEPTH_32BPP) != VID_DEPTH_32BPP); break;
 382           default: err=1; break;
 383         }
 384         if(err)
 385         {
 386           mp_msg(MSGT_VO,MSGL_ERR, MSGTR_LIBVO_SUB_VIDIX_VideoServerHasUnsupportedColorDepth
 387           ,vidix_fourcc.depth);
 388           return -1;
 389         }
 390         if((dst_width > src_width || dst_height > src_height) && (vidix_cap.flags & FLAG_UPSCALER) != FLAG_UPSCALER)
 391         {
 392           mp_msg(MSGT_VO,MSGL_ERR, MSGTR_LIBVO_SUB_VIDIX_DriverCantUpscaleImage,
 393           src_width, src_height, dst_width, dst_height);
 394           return -1;
 395         }
 396         if((dst_width > src_width || dst_height > src_height) && (vidix_cap.flags & FLAG_DOWNSCALER) != FLAG_DOWNSCALER)
 397         {
 398           mp_msg(MSGT_VO,MSGL_ERR, MSGTR_LIBVO_SUB_VIDIX_DriverCantDownscaleImage,
 399           src_width, src_height, dst_width, dst_height);
 400           return -1;
 401         }
 402         image_width = src_width;
 403         image_height = src_height;
 404         src_format = format;
 405         if(forced_fourcc) format = forced_fourcc;
 406         memset(&vidix_play,0,sizeof(vidix_playback_t));
 407         vidix_play.fourcc = format;
 408         vidix_play.capability = vidix_cap.flags; /* every ;) */
 409         vidix_play.blend_factor = 0; /* for now */
 410         /* display the full picture.
 411            Nick: we could implement here zooming to a specified area -- alex */
 412         vidix_play.src.x = vidix_play.src.y = 0;
 413         vidix_play.src.w = src_width;
 414         vidix_play.src.h = src_height;
 415         vidix_play.dest.x = x_org;
 416         vidix_play.dest.y = y_org;
 417         vidix_play.dest.w = dst_width;
 418         vidix_play.dest.h = dst_height;
 419 //      vidix_play.num_frames=vo_doublebuffering?NUM_FRAMES-1:1;
 420         /* we aren't mad...3 buffers are more than enough */
 421         vidix_play.num_frames=vo_doublebuffering?3:1;
 422         vidix_play.src.pitch.y = vidix_play.src.pitch.u = vidix_play.src.pitch.v = 0;
 423
 424         if((err=vdlConfigPlayback(vidix_handler,&vidix_play))!=0)
 425         {
 426                 mp_msg(MSGT_VO,MSGL_ERR, MSGTR_LIBVO_SUB_VIDIX_CantConfigurePlayback,strerror(err));
 427                 return -1;
 428         }
 429         if ( mp_msg_test(MSGT_VO,MSGL_V) ) {
 430                 mp_msg(MSGT_VO,MSGL_V, "vosub_vidix: using %d buffer(s)\n", vidix_play.num_frames); }
 431
 432         vidix_mem = vidix_play.dga_addr;
 433
 434         tmp = calloc(image_width, image_height);
 435         tmpa = malloc(image_width * image_height);
 436         memset(tmpa, 1, image_width * image_height);
 437         /* clear every frame with correct address and frame_size */
 438         /* HACK: use draw_alpha to clear Y component */
 439         for (i = 0; i < vidix_play.num_frames; i++) {
 440             next_frame = i;
 441             memset(vidix_mem + vidix_play.offsets[i], 0x80,
 442                 vidix_play.frame_size);
 443             draw_alpha(0, 0, image_width, image_height, tmp, tmpa, image_width);
 444         }
 445         free(tmp);
 446         free(tmpa);
 447         /* show one of the "clear" frames */
 448         vidix_flip_page();
 449
 450         switch(format)
 451         {
 452             case IMGFMT_YV12:
 453             case IMGFMT_I420:
 454             case IMGFMT_IYUV:
 455             case IMGFMT_YVU9:
 456             case IMGFMT_IF09:
 457             case IMGFMT_Y800:
 458             case IMGFMT_Y8:
 459                 apitch = vidix_play.dest.pitch.y-1;
 460                 dstrides.y = (image_width + apitch) & ~apitch;
 461                 apitch = vidix_play.dest.pitch.v-1;
 462                 dstrides.v = (image_width + apitch) & ~apitch;
 463                 apitch = vidix_play.dest.pitch.u-1;
 464                 dstrides.u = (image_width + apitch) & ~apitch;
 465                 image_Bpp=1;
 466                 break;
 467             case IMGFMT_RGB32:
 468             case IMGFMT_BGR32:
 469                 apitch = vidix_play.dest.pitch.y-1;
 470                 dstrides.y = (image_width*4 + apitch) & ~apitch;
 471                 dstrides.u = dstrides.v = 0;
 472                 image_Bpp=4;
 473                 break;
 474             case IMGFMT_RGB24:
 475             case IMGFMT_BGR24:
 476                 apitch = vidix_play.dest.pitch.y-1;
 477                 dstrides.y = (image_width*3 + apitch) & ~apitch;
 478                 dstrides.u = dstrides.v = 0;
 479                 image_Bpp=3;
 480                 break;
 481             default:
 482                 apitch = vidix_play.dest.pitch.y-1;
 483                 dstrides.y = (image_width*2 + apitch) & ~apitch;
 484                 dstrides.u = dstrides.v = 0;
 485                 image_Bpp=2;
 486                 break;
 487         }
 488         /* tune some info here */
 489         sstride = src_width*image_Bpp;
 490         if(!forced_fourcc)
 491         {
 492             is_422_planes_eq = sstride == dstrides.y;
 493
 494             if(src_format == IMGFMT_YV12 || src_format == IMGFMT_I420 || src_format == IMGFMT_IYUV)
 495                  vo_server->draw_slice = vidix_draw_slice_420;
 496             else if (src_format == IMGFMT_YVU9 || src_format == IMGFMT_IF09)
 497                  vo_server->draw_slice = vidix_draw_slice_410;
 498             else vo_server->draw_slice = vidix_draw_slice_packed;
 499         }
 500         return 0;
 501 }
 502
 503 static uint32_t vidix_get_image(mp_image_t *mpi)
 504 {
 505     if(mpi->type==MP_IMGTYPE_STATIC && vidix_play.num_frames>1) return VO_FALSE;
 506     if(mpi->flags&MP_IMGFLAG_READABLE) return VO_FALSE; /* slow video ram */
 507     if(( (mpi->stride[0]==dstrides.y && (!(mpi->flags&MP_IMGFLAG_PLANAR) ||
 508       (mpi->stride[1]==dstrides.u && mpi->stride[2]==dstrides.v)) )
 509       || (mpi->flags&(MP_IMGFLAG_ACCEPT_STRIDE|MP_IMGFLAG_ACCEPT_WIDTH))) &&
 510        (!forced_fourcc && !(vidix_play.flags & VID_PLAY_INTERLEAVED_UV)))
 511     {
 512         if(mpi->flags&MP_IMGFLAG_ACCEPT_WIDTH){
 513             // check if only width is enough to represent strides:
 514             if(mpi->flags&MP_IMGFLAG_PLANAR){
 515                 if((dstrides.y>>1)!=dstrides.v || dstrides.v!=dstrides.u) return VO_FALSE;
 516             } else {
 517                 if(dstrides.y % (mpi->bpp/8)) return VO_FALSE;
 518             }
 519         }
 520         mpi->planes[0]=vidix_mem+vidix_play.offsets[next_frame]+vidix_play.offset.y;
 521         mpi->width=mpi->stride[0]=dstrides.y;
 522         if(mpi->flags&MP_IMGFLAG_PLANAR)
 523         {
 524             mpi->planes[1]=vidix_mem+vidix_play.offsets[next_frame]+vidix_play.offset.v;
 525             mpi->stride[1]=dstrides.v >> mpi->chroma_x_shift;
 526             mpi->planes[2]=vidix_mem+vidix_play.offsets[next_frame]+vidix_play.offset.u;
 527             mpi->stride[2]=dstrides.u >> mpi->chroma_x_shift;
 528         } else
 529             mpi->width/=mpi->bpp/8;
 530         mpi->flags|=MP_IMGFLAG_DIRECT;
 531         return VO_TRUE;
 532     }
 533     return VO_FALSE;
 534 }
 535
 536 uint32_t vidix_control(uint32_t request, void *data, ...)
 537 {
 538   switch (request) {
 539   case VOCTRL_QUERY_FORMAT:
 540     return vidix_query_fourcc(*((uint32_t*)data));
 541   case VOCTRL_GET_IMAGE:
 542     return vidix_get_image(data);
 543   case VOCTRL_DRAW_IMAGE:
 544     return vidix_draw_image(data);
 545   case VOCTRL_GET_FRAME_NUM:
 546         *(uint32_t *)data = next_frame;
 547         return VO_TRUE;
 548   case VOCTRL_SET_FRAME_NUM:
 549         next_frame = *(uint32_t *)data;
 550         return VO_TRUE;
 551   case VOCTRL_GET_NUM_FRAMES:
 552         *(uint32_t *)data = vidix_play.num_frames;
 553         return VO_TRUE;
 554   case VOCTRL_SET_EQUALIZER:
 555   {
 556     va_list ap;
 557     int value;
 558     vidix_video_eq_t info;
 559
 560     if(!video_on) return VO_FALSE;
 561     va_start(ap, data);
 562     value = va_arg(ap, int);
 563     va_end(ap);
 564
 565 //    printf("vidix seteq %s -> %d  \n",data,value);
 566
 567     /* vidix eq ranges are -1000..1000 */
 568     if (!strcasecmp(data, "brightness"))
 569     {
 570         info.brightness = value*10;
 571         info.cap = VEQ_CAP_BRIGHTNESS;
 572     }
 573     else if (!strcasecmp(data, "contrast"))
 574     {
 575         info.contrast = value*10;
 576         info.cap = VEQ_CAP_CONTRAST;
 577     }
 578     else if (!strcasecmp(data, "saturation"))
 579     {
 580         info.saturation = value*10;
 581         info.cap = VEQ_CAP_SATURATION;
 582     }
 583     else if (!strcasecmp(data, "hue"))
 584     {
 585         info.hue = value*10;
 586         info.cap = VEQ_CAP_HUE;
 587     }
 588
 589     if (vdlPlaybackSetEq(vidix_handler, &info) == 0)
 590         return VO_TRUE;
 591     return VO_FALSE;
 592   }
 593   case VOCTRL_GET_EQUALIZER:
 594   {
 595     va_list ap;
 596     int *value;
 597     vidix_video_eq_t info;
 598
 599     if(!video_on) return VO_FALSE;
 600     if (vdlPlaybackGetEq(vidix_handler, &info) != 0)
 601         return VO_FALSE;
 602
 603     va_start(ap, data);
 604     value = va_arg(ap, int*);
 605     va_end(ap);
 606
 607     /* vidix eq ranges are -1000..1000 */
 608     if (!strcasecmp(data, "brightness"))
 609     {
 610         if (info.cap & VEQ_CAP_BRIGHTNESS)
 611             *value = info.brightness/10;
 612     }
 613     else if (!strcasecmp(data, "contrast"))
 614     {
 615         if (info.cap & VEQ_CAP_CONTRAST)
 616             *value = info.contrast/10;
 617     }
 618     else if (!strcasecmp(data, "saturation"))
 619     {
 620         if (info.cap & VEQ_CAP_SATURATION)
 621             *value = info.saturation/10;
 622     }
 623     else if (!strcasecmp(data, "hue"))
 624     {
 625         if (info.cap & VEQ_CAP_HUE)
 626             *value = info.hue/10;
 627     }
 628
 629     return VO_TRUE;
 630   }
 631   }
 632   return VO_NOTIMPL;
 633   // WARNING: we drop extra parameters (...) here!
 634 //  return server_control(request,data); //VO_NOTIMPL;
 635 }
 636
 637 int vidix_preinit(const char *drvname,vo_functions_t *server)
 638 {
 639   int err;
 640   if( mp_msg_test(MSGT_VO,MSGL_DBG2) ) {
 641     mp_msg(MSGT_VO,MSGL_DBG2, "vosub_vidix: vidix_preinit(%s) was called\n",drvname); }
 642         if(vdlGetVersion() != VIDIX_VERSION)
 643         {
 644           mp_msg(MSGT_VO,MSGL_ERR, MSGTR_LIBVO_SUB_VIDIX_YouHaveWrongVersionOfVidixLibrary);
 645           return -1;
 646         }
 647 #ifndef __MINGW32__
 648         vidix_handler = vdlOpen(MP_VIDIX_PFX,
 649                                 drvname ? drvname[0] == ':' ? &drvname[1] : drvname[0] ? drvname : NULL : NULL,
 650                                 TYPE_OUTPUT,
 651                                 verbose);
 652 #else
 653         vidix_handler = vdlOpen(get_path("vidix/"),
 654                                 drvname ? drvname[0] == ':' ? &drvname[1] : drvname[0] ? drvname : NULL : NULL,
 655                                 TYPE_OUTPUT,
 656                                 verbose);
 657 #endif
 658
 659         if(vidix_handler == NULL)
 660         {
 661                 mp_msg(MSGT_VO,MSGL_ERR, MSGTR_LIBVO_SUB_VIDIX_CouldntFindWorkingVidixDriver);
 662                 return -1;
 663         }
 664         if((err=vdlGetCapability(vidix_handler,&vidix_cap)) != 0)
 665         {
 666                 mp_msg(MSGT_VO,MSGL_ERR, MSGTR_LIBVO_SUB_VIDIX_CouldntGetCapability,strerror(err));
 667                 return -1;
 668         }
 669         mp_msg(MSGT_VO,MSGL_INFO, MSGTR_LIBVO_SUB_VIDIX_Description, vidix_cap.name);
 670         mp_msg(MSGT_VO,MSGL_INFO, MSGTR_LIBVO_SUB_VIDIX_Author, vidix_cap.author);
 671         /* we are able to tune up this stuff depend on fourcc format */
 672         server->draw_slice=vidix_draw_slice;
 673         server->draw_frame=vidix_draw_frame;
 674         server->flip_page=vidix_flip_page;
 675         server->draw_osd=vidix_draw_osd;
 676 //      server_control = server->control;
 677 //      server->control=vidix_control;
 678         vo_server = server;
 679         return 0;
 680 }