libvo/vo_directfb2.c

   1 /*
   2  * MPlayer video driver for DirectFramebuffer device
   3  *
   4  * copyright (C) 2002 Jiri Svoboda <Jiri.Svoboda@seznam.cz>
   5  *
   6  * based on vo_directfb2.c
   7  *
   8  * This file is part of MPlayer.
   9  *
  10  * MPlayer is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * MPlayer is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with MPlayer; if not, write to the Free Software Foundation, Inc.,
  22  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  23  */
  24
  25 // directfb includes
  26
  27 #include <directfb.h>
  28
  29 #define DFB_VERSION(a,b,c) (((a)<<16)|((b)<<8)|(c))
  30
  31 // other things
  32
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36
  37 #ifdef __linux__
  38 #include <sys/kd.h>
  39 #else
  40 #include <linux/kd.h>
  41 #endif
  42
  43 #include "config.h"
  44 #include "video_out.h"
  45 #include "video_out_internal.h"
  46 #include "fastmemcpy.h"
  47 #include "sub.h"
  48 #include "mp_msg.h"
  49 #include "aspect.h"
  50 #include "subopt-helper.h"
  51 #include "mp_fifo.h"
  52
  53 #ifndef min
  54 #define min(x,y) (((x)<(y))?(x):(y))
  55 #endif
  56
  57 #if DIRECTFBVERSION > DFB_VERSION(0,9,17)
  58 // triple buffering
  59 #define TRIPLE 1
  60 #endif
  61
  62 static const vo_info_t info = {
  63         "Direct Framebuffer Device",
  64         "directfb",
  65         "Jiri Svoboda Jiri.Svoboda@seznam.cz",
  66         "v 2.0 (for DirectFB version >=0.9.13)"
  67 };
  68
  69 const LIBVO_EXTERN(directfb)
  70
  71 /******************************
  72 *      vo_directfb globals    *
  73 ******************************/
  74
  75 #define DFBCHECK(x...)                                         \
  76   {                                                            \
  77     DFBResult err = x;                                         \
  78                                                                \
  79     if (err != DFB_OK)                                         \
  80       {                                                        \
  81         fprintf( stderr, "%s <%d>:\n\t", __FILE__, __LINE__ ); \
  82         DirectFBErrorFatal( #x, err );                         \
  83       }                                                        \
  84   }
  85
  86  /*
  87  *  filled by preinit
  88  */
  89
  90 // main DirectFB handle
  91 static IDirectFB *dfb = NULL;
  92 // keyboard handle
  93 static IDirectFBInputDevice *keyboard = NULL;
  94 // A buffer for input events.
  95 static IDirectFBEventBuffer *buffer = NULL;
  96
  97  /*
  98  *  filled during config
  99  */
 100
 101 // handle of used layer
 102 static IDirectFBDisplayLayer *layer = NULL;
 103 // surface of used layer
 104 static IDirectFBSurface *primary = NULL;
 105 static int primarylocked = 0;
 106 // handle of temporary surface (if used)
 107 static IDirectFBSurface *frame = NULL;
 108 static int framelocked = 0;
 109 // flipping mode flag (layer/surface)
 110 static int flipping = 0;
 111 // scaling flag
 112 static int stretch = 0;
 113 // picture position
 114 static int xoffset=0,yoffset=0;
 115 // picture size
 116 static int out_width=0,out_height=0;
 117 // frame/primary size
 118 static int width=0,height=0;
 119 // frame primary format
 120 DFBSurfacePixelFormat pixel_format;
 121 /*
 122 static void (*draw_alpha_p)(int w, int h, unsigned char *src,
 123                 unsigned char *srca, int stride, unsigned char *dst,
 124                 int dstride);
 125 */
 126
 127 /******************************
 128 * cmd line parameteres        *
 129 ******************************/
 130
 131 /* command line/config file options */
 132 static int layer_id = -1;
 133 static int buffer_mode = 1;
 134 static int use_input = 1;
 135 static int field_parity = -1;
 136
 137 /******************************
 138 *          implementation     *
 139 ******************************/
 140
 141 static void unlock(void)
 142 {
 143 if (frame && framelocked) frame->Unlock(frame);
 144 if (primary && primarylocked) primary->Unlock(primary);
 145 }
 146
 147 static int get_parity(strarg_t *arg) {
 148   if (strargcmp(arg, "top") == 0)
 149     return 0;
 150   if (strargcmp(arg, "bottom") == 0)
 151     return 1;
 152   return -1;
 153 }
 154
 155 static int check_parity(void *arg) {
 156   return get_parity(arg) != -1;
 157 }
 158
 159 static int get_mode(strarg_t *arg) {
 160   if (strargcmp(arg, "single") == 0)
 161     return 1;
 162   if (strargcmp(arg, "double") == 0)
 163     return 2;
 164   if (strargcmp(arg, "triple") == 0)
 165     return 3;
 166   return 0;
 167 }
 168
 169 static int check_mode(void *arg) {
 170   return get_mode(arg) != 0;
 171 }
 172
 173 static int preinit(const char *arg)
 174 {
 175     DFBResult ret;
 176     strarg_t mode_str = {0, NULL};
 177     strarg_t par_str = {0, NULL};
 178     strarg_t dfb_params = {0, NULL};
 179     const opt_t subopts[] = {
 180       {"input",       OPT_ARG_BOOL, &use_input,  NULL},
 181       {"buffermode",  OPT_ARG_STR,  &mode_str,   check_mode},
 182       {"fieldparity", OPT_ARG_STR,  &par_str,    check_parity},
 183       {"layer",       OPT_ARG_INT,  &layer_id,   NULL},
 184       {"dfbopts",     OPT_ARG_STR,  &dfb_params, NULL},
 185       {NULL}
 186     };
 187
 188     //mp_msg(MSGT_VO, MSGL_INFO,"DirectFB: Preinit entered\n");
 189
 190     if (dfb) return 0; // we are already initialized!
 191
 192     // set defaults
 193     buffer_mode = 1 + vo_doublebuffering; // honor -double switch
 194     layer_id = -1;
 195     use_input = 1;
 196     field_parity = -1;
 197      if (subopt_parse(arg, subopts) != 0) {
 198                mp_msg( MSGT_VO, MSGL_ERR,
 199                        "\n-vo directfb command line help:\n"
 200                        "Example: mplayer -vo directfb:layer=1:buffermode=single\n"
 201                        "\nOptions (use 'no' prefix to disable):\n"
 202                        "  input  Use DirectFB for keyboard input\n"
 203                        "\nOther options:\n"
 204                        "  layer=n\n"
 205                        "    n=0..xx   Use layer with id n for output (0=primary)\n"
 206                        "  buffermode=(single|double|triple)\n"
 207                        "    single   Use single buffering\n"
 208                        "    double   Use double buffering\n"
 209                        "    triple   Use triple buffering\n"
 210                        "  fieldparity=(top|bottom)\n"
 211                        "    top      Top field first\n"
 212                        "    bottom   Bottom field first\n"
 213                        "  dfbopts=<str>\n"
 214                        "    Specify a parameter list for DirectFB\n"
 215                        "\n" );
 216                return -1;
 217      }
 218     if (mode_str.len)
 219       buffer_mode = get_mode(&mode_str);
 220     if (par_str.len)
 221       field_parity = get_parity(&par_str);
 222
 223
 224         if (dfb_params.len > 0)
 225         {
 226             int argc = 2;
 227             char arg0[10] = "mplayer";
 228             char *arg1 = malloc(dfb_params.len + 7);
 229             char* argv[3];
 230             char ** a;
 231
 232             a = &argv[0];
 233
 234             strcpy(arg1, "--dfb:");
 235             strncat(arg1, dfb_params.str, dfb_params.len);
 236
 237             argv[0]=arg0;
 238             argv[1]=arg1;
 239             argv[2]=NULL;
 240
 241             DFBCHECK (DirectFBInit (&argc,&a));
 242
 243             free(arg1);
 244         } else {
 245
 246         DFBCHECK (DirectFBInit (NULL,NULL));
 247         }
 248
 249         if (((directfb_major_version <= 0) &&
 250             (directfb_minor_version <= 9) &&
 251             (directfb_micro_version < 13)))
 252         {
 253             mp_msg(MSGT_VO, MSGL_ERR,"DirectFB: Unsupported DirectFB version\n");
 254             return 1;
 255         }
 256
 257   /*
 258    * (set options)
 259    */
 260
 261 //      uncomment this if you do not wish to create a new VT for DirectFB
 262 //        DFBCHECK (DirectFBSetOption ("no-vt-switch",""));
 263
 264 //      uncomment this if you want to allow VT switching
 265 //       DFBCHECK (DirectFBSetOption ("vt-switching",""));
 266
 267 //      uncomment this if you want to hide gfx cursor (req dfb >=0.9.9)
 268         DFBCHECK (DirectFBSetOption ("no-cursor",""));
 269
 270 // bg color fix
 271         DFBCHECK (DirectFBSetOption ("bg-color","00000000"));
 272
 273   /*
 274    * (Initialize)
 275    */
 276
 277         DFBCHECK (DirectFBCreate (&dfb));
 278
 279 #if DIRECTFBVERSION < DFB_VERSION(0,9,17)
 280         if (DFB_OK != dfb->SetCooperativeLevel (dfb, DFSCL_FULLSCREEN)) {
 281             mp_msg(MSGT_VO, MSGL_WARN,"DirectFB: Warning - cannot switch to fullscreen mode");
 282         };
 283 #endif
 284
 285   /*
 286    * (Get keyboard)
 287    */
 288
 289   if (use_input) {
 290     ret = dfb->GetInputDevice (dfb, DIDID_KEYBOARD, &keyboard);
 291     if (ret==DFB_OK) {
 292         mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Keyboard init OK\n");
 293     } else {
 294         keyboard = NULL;
 295         mp_msg(MSGT_VO, MSGL_ERR,"DirectFB: Keyboard init FAILED\n");
 296     }
 297   }
 298
 299
 300   /*
 301    * Create an input buffer for the keyboard.
 302    */
 303   if (keyboard) DFBCHECK (keyboard->CreateEventBuffer (keyboard, &buffer));
 304
 305   // just to start clean ...
 306   if (buffer) buffer->Reset(buffer);
 307
 308   //mp_msg(MSGT_VO, MSGL_INFO,"DirectFB: Preinit OK\n");
 309
 310   return 0;
 311
 312 }
 313
 314 static DFBSurfacePixelFormat convformat(uint32_t format)
 315 {
 316 // add more formats !!!
 317         switch (format) {
 318             case IMGFMT_RGB32: return  DSPF_RGB32; break;
 319             case IMGFMT_BGR32: return  DSPF_RGB32; break;
 320             case IMGFMT_RGB24: return  DSPF_RGB24; break;
 321             case IMGFMT_BGR24: return  DSPF_RGB24; break;
 322             case IMGFMT_RGB16: return  DSPF_RGB16; break;
 323             case IMGFMT_BGR16: return  DSPF_RGB16; break;
 324 #if DIRECTFBVERSION > DFB_VERSION(0,9,15)
 325             case IMGFMT_RGB15: return  DSPF_ARGB1555; break;
 326             case IMGFMT_BGR15: return  DSPF_ARGB1555; break;
 327 #else
 328             case IMGFMT_RGB15: return  DSPF_RGB15; break;
 329             case IMGFMT_BGR15: return  DSPF_RGB15; break;
 330 #endif
 331             case IMGFMT_YUY2:  return  DSPF_YUY2; break;
 332             case IMGFMT_UYVY:  return  DSPF_UYVY; break;
 333             case IMGFMT_YV12:  return  DSPF_YV12; break;
 334             case IMGFMT_I420:  return  DSPF_I420; break;
 335 //          case IMGFMT_IYUV:  return  DSPF_IYUV; break;
 336             case IMGFMT_RGB8:  return  DSPF_RGB332; break;
 337             case IMGFMT_BGR8:  return  DSPF_RGB332; break;
 338
 339             default: return 0;
 340         }
 341 return 0;
 342 }
 343
 344 typedef struct enum1_s {
 345 uint32_t format;
 346 int scale;
 347 int result;
 348 unsigned int id;
 349 unsigned int width;
 350 unsigned int height;
 351 int setsize;
 352 } enum1_t;
 353
 354 static DFBEnumerationResult test_format_callback(unsigned int id,
 355                                                  DFBDisplayLayerDescription  desc,
 356                                                  void *data)
 357 {
 358      enum1_t *params =(enum1_t *)data;
 359      IDirectFBDisplayLayer *layer;
 360      DFBResult ret;
 361
 362      if ((layer_id == -1 )||(layer_id == id)) {
 363
 364      ret = dfb->GetDisplayLayer( dfb, id, &layer);
 365      if (ret) {
 366                DirectFBError( "dfb->GetDisplayLayer failed", ret );
 367                return DFENUM_OK;
 368      } else {
 369         DFBDisplayLayerConfig        dlc;
 370
 371         if (params->setsize) {
 372             dlc.flags   = DLCONF_WIDTH |DLCONF_HEIGHT;
 373             dlc.width   = params->width;
 374             dlc.height  = params->height;
 375             layer->SetConfiguration(layer,&dlc);
 376         }
 377
 378
 379         dlc.flags       = DLCONF_PIXELFORMAT;
 380         dlc.pixelformat = convformat(params->format);
 381
 382         layer->SetOpacity(layer,0);
 383
 384         ret = layer->TestConfiguration(layer,&dlc,NULL);
 385
 386         layer->Release(layer);
 387
 388         mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Test format - layer %i scale/pos %i\n",id,(desc.caps & DLCAPS_SCREEN_LOCATION));
 389
 390         if (ret==DFB_OK) {
 391 //          printf("Test OK\n");
 392             if (params->result) {
 393                 if  ((!params->scale) && (desc.caps & DLCAPS_SCREEN_LOCATION)) {
 394                     params->scale=1;
 395                     params->id=id;
 396                     mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Test format - added layer %i scale/pos %i\n",id,(desc.caps & DLCAPS_SCREEN_LOCATION));
 397                 }
 398             } else {
 399                 params->result=1;
 400                 params->id=id;
 401                 if (desc.caps & DLCAPS_SCREEN_LOCATION) params->scale=1;
 402                 mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Test format - added layer %i scale/pos %i\n",id,(desc.caps & DLCAPS_SCREEN_LOCATION));
 403            };
 404         };
 405      };
 406
 407     };
 408
 409     return DFENUM_OK;
 410 }
 411
 412 static int query_format(uint32_t format)
 413 {
 414         int ret = VFCAP_CSP_SUPPORTED|VFCAP_CSP_SUPPORTED_BY_HW|VFCAP_OSD; // osd should be removed the in future -> will be handled outside...
 415         enum1_t params;
 416
 417
 418         if (!convformat(format)) return 0;
 419 // temporarily disable YV12
 420 //      if (format == IMGFMT_YV12) return 0;
 421 //      if (format == IMGFMT_I420) return 0;
 422         if (format == IMGFMT_IYUV) return 0;
 423
 424         mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Format query: %s\n",vo_format_name(format));
 425
 426         params.format=format;
 427         params.scale=0;
 428         params.result=0;
 429         params.setsize=0;
 430
 431         DFBCHECK (dfb->EnumDisplayLayers(dfb,test_format_callback,&params));
 432
 433         if (params.result) {
 434             if (params.scale) ret |=VFCAP_HWSCALE_UP|VFCAP_HWSCALE_DOWN;
 435             return ret;
 436         }
 437
 438         return 0;
 439 }
 440
 441 typedef struct videomode_s {
 442 int width;
 443 int height;
 444 int out_width;
 445 int out_height;
 446 int overx;
 447 int overy;
 448 int bpp;
 449 } videomode_t;
 450
 451
 452 static DFBEnumerationResult video_modes_callback(int width, int height,
 453                                                  int bpp, void *data)
 454 {
 455      videomode_t *params =(videomode_t *)data;
 456
 457 int overx=0,overy=0,closer=0,over=0;
 458 int we_are_under=0;
 459
 460 //mp_msg(MSGT_VO, MSGL_INFO,"DirectFB: Validator entered %i %i %i\n",width,height,bpp);
 461
 462 overx=width-params->out_width;
 463 overy=height-params->out_height;
 464
 465 if (!params->width) {
 466         params->width=width;
 467         params->height=height;
 468         params->overx=overx;
 469         params->overy=overy;
 470         mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Mode added %i %i %i\n",width,height,bpp);
 471 }
 472
 473 if ((params->overy<0)||(params->overx<0)) we_are_under=1; // stored mode is smaller than req mode
 474 if (abs(overx*overy)<abs(params->overx * params->overy)) closer=1; // current mode is closer to desired res
 475 if ((overx>=0)&&(overy>=0)) over=1; // current mode is bigger or equaul to desired res
 476 if ((closer && (over || we_are_under)) || (we_are_under && over)) {
 477                 params->width=width;
 478                 params->height=height;
 479                 params->overx=overx;
 480                 params->overy=overy;
 481                 mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Better mode added %i %i %i\n",width,height,bpp);
 482                 };
 483
 484 return DFENUM_OK;
 485 }
 486
 487 #define CONFIG_ERROR -1
 488
 489 static int config(uint32_t s_width, uint32_t s_height, uint32_t d_width,
 490                 uint32_t d_height, uint32_t flags, char *title,
 491                 uint32_t format)
 492 {
 493   /*
 494    * (Locals)
 495    */
 496
 497 // decode flags
 498
 499         int fs = flags & VOFLAG_FULLSCREEN;
 500         int vm = flags & VOFLAG_MODESWITCHING;
 501
 502         DFBSurfaceDescription dsc;
 503         DFBResult             ret;
 504         DFBDisplayLayerConfig dlc;
 505         DFBSurfaceCapabilities caps;
 506
 507         enum1_t params;
 508
 509         mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Config entered [%ix%i]\n",s_width,s_height);
 510         mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: With requested format: %s\n",vo_format_name(format));
 511
 512 // initial cleanup
 513         if (frame) {
 514             frame->Release(frame);
 515             frame=NULL;
 516         }
 517
 518         if (primary) {
 519             primary->Release(primary);
 520             primary=NULL;
 521         }
 522
 523         if (layer) {
 524             layer->Release(layer);
 525             layer=NULL;
 526         }
 527
 528
 529 // vm things
 530
 531         if (vm) {
 532             videomode_t params;
 533             params.out_width=d_width;
 534             params.out_height=d_height;
 535             params.width=0;
 536             params.height=0;
 537             switch (format) {
 538                     case IMGFMT_RGB32:
 539                     case IMGFMT_BGR32:
 540                                         params.bpp=32;
 541                                         break;
 542                     case IMGFMT_RGB24:
 543                     case IMGFMT_BGR24:
 544                                         params.bpp=24;
 545                                         break;
 546                     case IMGFMT_RGB16:
 547                     case IMGFMT_BGR16:
 548                     case IMGFMT_RGB15:
 549                     case IMGFMT_BGR15:
 550                                         params.bpp=16;
 551                                         break;
 552                     default:            params.bpp=0;
 553
 554             }
 555             mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Config - trying to change videomode\n");
 556             DFBCHECK (dfb->EnumVideoModes(dfb,video_modes_callback,&params));
 557             ret=dfb->SetVideoMode(dfb,params.width,params.height,params.bpp);
 558             if (ret) {
 559                 ret=dfb->SetVideoMode(dfb,params.width,params.height,24);
 560                     if (ret) {
 561                         ret=dfb->SetVideoMode(dfb,params.width,params.height,32);
 562                             if (ret) {
 563                                 ret=dfb->SetVideoMode(dfb,params.width,params.height,16);
 564                                     if (ret) {
 565                                         ret=dfb->SetVideoMode(dfb,params.width,params.height,8);
 566                                     }
 567                             }
 568                     }
 569             }
 570         } // vm end
 571
 572 // just to be sure clear primary layer
 573 #if DIRECTFBVERSION > DFB_VERSION(0,9,13)
 574         ret = dfb->GetDisplayLayer( dfb, DLID_PRIMARY, &layer);
 575         if (ret==DFB_OK) {
 576             ret = layer->GetSurface(layer,&primary);
 577             if (ret==DFB_OK) {
 578                 primary->Clear(primary,0,0,0,0xff);
 579                 ret = primary->Flip(primary,NULL,0);
 580                 if (ret==DFB_OK) {
 581                     primary->Clear(primary,0,0,0,0xff);
 582                 }
 583             primary->Release(primary);
 584             }
 585         primary=NULL;
 586         layer->Release(layer);
 587         }
 588         layer=NULL;
 589 #endif
 590
 591 // find best layer
 592
 593         mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Config - looking for suitable layer\n");
 594         params.format=format;
 595         params.scale=0;
 596         params.result=0;
 597         params.width=s_width;
 598         params.height=s_height;
 599         params.setsize=1;
 600
 601         DFBCHECK (dfb->EnumDisplayLayers(dfb,test_format_callback,&params));
 602
 603         if (!params.result) {
 604             mp_msg(MSGT_VO, MSGL_ERR,"DirectFB: ConfigError - no suitable layer found\n");
 605             params.id = DLID_PRIMARY;
 606         }
 607
 608         mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Config - layer %i\n",params.id);
 609
 610         // setup layer
 611
 612         DFBCHECK (dfb->GetDisplayLayer( dfb, params.id, &layer));
 613
 614 #if DIRECTFBVERSION > DFB_VERSION(0,9,16)
 615         mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Config - switching layer to exclusive mode\n");
 616         ret = layer->SetCooperativeLevel (layer, DLSCL_EXCLUSIVE);
 617
 618         if (DFB_OK != ret) {
 619             mp_msg(MSGT_VO, MSGL_WARN,"DirectFB: Warning - cannot switch layer to exclusive mode. This could cause\nproblems. You may need to select correct pixel format manually!\n");
 620             DirectFBError("MPlayer - Switch layer to exlusive mode.",ret);
 621         };
 622 #endif
 623         if (params.scale) {
 624             mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Config - changing layer configuration (size)\n");
 625             dlc.flags       = DLCONF_WIDTH | DLCONF_HEIGHT;
 626             dlc.width       = s_width;
 627             dlc.height      = s_height;
 628
 629             ret = layer->SetConfiguration(layer,&dlc);
 630
 631             if (ret) {
 632                 mp_msg(MSGT_VO, MSGL_ERR,"DirectFB: ConfigError in layer configuration (size)\n");
 633                 DirectFBError("MPlayer - Layer size change.",ret);
 634             };
 635         }
 636
 637         // look if we need to change the pixel format of the layer
 638         // and just to be sure also fetch all layer properties
 639         dlc.flags       = DLCONF_PIXELFORMAT | DLCONF_WIDTH | DLCONF_HEIGHT | DLCONF_OPTIONS | DLCONF_BUFFERMODE;
 640
 641         ret = layer->GetConfiguration(layer,&dlc);
 642
 643         dlc.flags       = DLCONF_PIXELFORMAT | DLCONF_WIDTH | DLCONF_HEIGHT;
 644
 645         if (ret) {
 646             mp_msg(MSGT_VO, MSGL_WARN,"DirectFB: Warning - could not get layer properties!\n");
 647         } else {
 648             mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Layer reports format:%x\n",dlc.pixelformat);
 649         }
 650
 651         if ((dlc.pixelformat != convformat(params.format)) || (ret != DFB_OK)) {
 652
 653             dlc.flags       = DLCONF_PIXELFORMAT;
 654             dlc.pixelformat = convformat(params.format);
 655
 656             mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Desired pixelformat: %x\n",dlc.pixelformat);
 657
 658             mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Config - changing layer configuration (format)\n");
 659             ret = layer->SetConfiguration(layer,&dlc);
 660
 661             if (ret) {
 662                 unsigned int bpp;
 663                 mp_msg(MSGT_VO, MSGL_ERR,"DirectFB: ConfigError in layer configuration (format, flags=%x)\n",dlc.flags);
 664                 DirectFBError("MPlayer - layer pixelformat change",ret);
 665
 666                 // ugly fbdev workaround - try to switch pixelformat via videomode change
 667                 switch (dlc.pixelformat) {
 668                     case DSPF_ARGB:
 669                     case DSPF_RGB32: bpp=32;break;
 670                     case DSPF_RGB24: bpp=24;break;
 671                     case DSPF_RGB16: bpp=16;break;
 672 #if DIRECTFBVERSION > DFB_VERSION(0,9,15)
 673                     case DSPF_ARGB1555: bpp=15;break;
 674 #else
 675                     case DSPF_RGB15: bpp=15;break;
 676 #endif
 677                     case DSPF_RGB332 : bpp=8;break;
 678                 }
 679
 680                 switch (dlc.pixelformat) {
 681                     case DSPF_ARGB:
 682                     case DSPF_RGB32:
 683                     case DSPF_RGB24:
 684                     case DSPF_RGB16:
 685 #if DIRECTFBVERSION > DFB_VERSION(0,9,15)
 686                     case DSPF_ARGB1555:
 687 #else
 688                     case DSPF_RGB15:
 689 #endif
 690                     case DSPF_RGB332:
 691                                     mp_msg(MSGT_VO, MSGL_V,"DirectFB: Trying to recover via videomode change (VM).\n");
 692                                     // get size
 693                                     dlc.flags = DLCONF_WIDTH | DLCONF_HEIGHT;
 694                                     if (DFB_OK==layer->GetConfiguration(layer,&dlc)) {
 695                                         // try to set videomode
 696                                         mp_msg(MSGT_VO, MSGL_V,"DirectFB: Videomode  %ix%i BPP %i\n",dlc.width,dlc.height,bpp);
 697                                         ret = dfb->SetVideoMode(dfb,dlc.width,dlc.height,bpp);
 698                                         if (ret) DirectFBError("MPlayer - VM - pixelformat change",ret);
 699
 700                                     };
 701
 702                                     //get current pixel format
 703                                     dlc.flags       = DLCONF_PIXELFORMAT;
 704                                     ret = layer->GetConfiguration(layer,&dlc);
 705                                     if (ret) {
 706                                         DirectFBError("MPlayer - VM - Layer->GetConfiguration",ret);
 707                                         } else {
 708                                         mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Layer now has pixelformat [%x]\n",dlc.pixelformat);
 709                                         };
 710
 711                                     // check if we were succesful
 712                                     if ((dlc.pixelformat != convformat(params.format)) || (ret != DFB_OK)) {
 713                                         mp_msg(MSGT_VO, MSGL_INFO,"DirectFB: Recovery failed!.\n");
 714                                         return CONFIG_ERROR;
 715                                         }
 716
 717                                     break;
 718
 719                     default: return CONFIG_ERROR;
 720
 721                 };
 722             };
 723         };
 724
 725 // flipping of layer
 726 // try triple, double... buffering
 727
 728         dlc.flags = DLCONF_BUFFERMODE;
 729 #ifdef TRIPLE
 730         if (buffer_mode > 2) {
 731             dlc.buffermode = DLBM_TRIPLE;
 732             ret = layer->SetConfiguration( layer, &dlc );
 733         } else {
 734             ret=!DFB_OK;
 735         }
 736
 737         if (ret!=DFB_OK) {
 738 #endif
 739             if (buffer_mode > 1) {
 740                     dlc.buffermode = DLBM_BACKVIDEO;
 741                     ret = layer->SetConfiguration( layer, &dlc );
 742                 if (ret!=DFB_OK) {
 743                     dlc.buffermode = DLBM_BACKSYSTEM;
 744                     ret = layer->SetConfiguration( layer, &dlc );
 745                 }
 746             }
 747             if (ret == DFB_OK) {
 748                 mp_msg(MSGT_VO, MSGL_V,"DirectFB: Double buffering is active\n");
 749             }
 750 #ifdef TRIPLE
 751         } else {
 752             mp_msg(MSGT_VO, MSGL_V,"DirectFB: Triple buffering is active\n");
 753         }
 754 #endif
 755
 756 #if DIRECTFBVERSION > DFB_VERSION(0,9,16)
 757         if (field_parity != -1) {
 758             dlc.flags = DLCONF_OPTIONS;
 759             ret = layer->GetConfiguration( layer, &dlc );
 760             if (ret==DFB_OK) {
 761                dlc.options |= DLOP_FIELD_PARITY;
 762                ret = layer->SetConfiguration( layer, &dlc );
 763                 if (ret==DFB_OK) {
 764                     layer->SetFieldParity( layer, field_parity );
 765                 }
 766             }
 767         }
 768         mp_msg( MSGT_VO, MSGL_DBG2, "DirectFB: Requested field parity: ");
 769           switch (field_parity) {
 770             case -1:
 771                 mp_msg( MSGT_VO, MSGL_DBG2, "Don't care\n");
 772                 break;
 773             case 0:
 774                 mp_msg( MSGT_VO, MSGL_DBG2, "Top field first\n");
 775                 break;
 776             case 1:
 777                 mp_msg( MSGT_VO, MSGL_DBG2, "Bottom field first\n");
 778                 break;
 779           }
 780
 781 #endif
 782
 783
 784 // get layer surface
 785
 786         ret = layer->GetSurface(layer,&primary);
 787
 788         if (ret) {
 789             mp_msg(MSGT_VO, MSGL_ERR,"DirectFB: ConfigError - could not get surface\n");
 790             return CONFIG_ERROR; // what shall we report on failure?
 791         }
 792
 793 // test surface for flipping
 794         DFBCHECK(primary->GetCapabilities(primary,&caps));
 795 #if DIRECTFBVERSION > DFB_VERSION(0,9,13)
 796         primary->Clear(primary,0,0,0,0xff);
 797 #endif
 798         flipping = 0;
 799         if (caps & (DSCAPS_FLIPPING
 800 #ifdef TRIPLE
 801         | DSCAPS_TRIPLE
 802 #endif
 803         )) {
 804             ret = primary->Flip(primary,NULL,0);
 805             if (ret==DFB_OK) {
 806                 flipping = 1;
 807 #if DIRECTFBVERSION > DFB_VERSION(0,9,13)
 808                 primary->Clear(primary,0,0,0,0xff);
 809 #ifdef TRIPLE
 810 // if we have 3 buffers clean once more
 811         if (caps & DSCAPS_TRIPLE) {
 812                 primary->Flip(primary,NULL,0);
 813                 primary->Clear(primary,0,0,0,0xff);
 814                 flipping = 2;
 815         }
 816 #endif
 817 #endif
 818             }
 819         };
 820
 821         mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Config - flipping = %i\n",flipping);
 822
 823 // is scale needed ? Aspect ratio and layer pos/size
 824
 825
 826         // get surface size
 827         DFBCHECK(primary->GetSize(primary,&width,&height));
 828
 829         mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Config - surface size = %ix%i\n",width,height);
 830
 831         aspect_save_orig(s_width,s_height);
 832         aspect_save_prescale(d_width,d_height);
 833         if (params.scale) {
 834                 aspect_save_screenres(10000,10000);
 835                 aspect(&out_width,&out_height,A_ZOOM);
 836
 837                 ret = layer->SetScreenLocation(layer,(1-(float)out_width/10000)/2,(1-(float)out_height/10000)/2,((float)out_width/10000),((float)out_height/10000));
 838
 839                 if (ret) mp_msg(MSGT_VO, MSGL_ERR,"DirectFB: ConfigError in layer configuration (position)\n");
 840
 841                 xoffset = 0;
 842                 yoffset = 0;
 843
 844         } else {
 845
 846                 aspect_save_screenres(width,height);
 847
 848                 if(fs) /* -fs */
 849                         aspect(&out_width,&out_height,A_ZOOM);
 850                 else
 851                         aspect(&out_width,&out_height,A_NOZOOM);
 852
 853
 854                 xoffset = (width - out_width) / 2;
 855                 yoffset = (height - out_height) / 2;
 856         }
 857
 858         if (((s_width==out_width)&&(s_height==out_height)) || (params.scale)) {
 859             stretch = 0;
 860         } else {
 861             stretch = 1;
 862         }
 863
 864
 865 // temporary buffer in case of not flipping or scaling
 866         if ((!flipping) || stretch) {
 867
 868             DFBCHECK (primary->GetPixelFormat (primary, &dsc.pixelformat));
 869
 870             dsc.flags = DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_WIDTH;
 871
 872             dsc.width = s_width;
 873             dsc.height = s_height;
 874
 875             DFBCHECK (dfb->CreateSurface( dfb, &dsc, &frame));
 876             DFBCHECK(frame->GetSize(frame,&width,&height));
 877             mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Frame is active.\n");
 878         }
 879
 880 // get format for draw_alpha - should be removed soon - osd will be rendered outside vo driver
 881         if (frame) {
 882                 DFBCHECK (frame->GetPixelFormat(frame,&pixel_format));
 883         } else {
 884                 DFBCHECK (primary->GetPixelFormat(primary,&pixel_format));
 885         };
 886
 887  // finally turn on layer
 888  layer->SetOpacity(layer,255);
 889
 890  //mp_msg(MSGT_VO, MSGL_INFO,"DirectFB: Config finished [%ix%i] - [%ix%i]\n",out_width,out_height,width,height);
 891
 892 return 0;
 893 }
 894
 895 #include "osdep/keycodes.h"
 896
 897 static void check_events(void)
 898 {
 899
 900 if (buffer) {
 901
 902       DFBInputEvent event;
 903
 904 //if ( mp_msg_test(MSGT_VO,MSGL_V) ) printf ("DirectFB: Check events entered\n");
 905      if (buffer->GetEvent(buffer, DFB_EVENT (&event)) == DFB_OK) {
 906
 907      if (event.type == DIET_KEYPRESS) {
 908                 switch (event.key_symbol) {
 909                                 case DIKS_ESCAPE:
 910                                         mplayer_put_key(KEY_ESC);
 911                                 break;
 912                                 case DIKS_PAGE_UP: mplayer_put_key(KEY_PAGE_UP);break;
 913                                 case DIKS_PAGE_DOWN: mplayer_put_key(KEY_PAGE_DOWN);break;
 914                                 case DIKS_CURSOR_UP: mplayer_put_key(KEY_UP);break;
 915                                 case DIKS_CURSOR_DOWN: mplayer_put_key(KEY_DOWN);break;
 916                                 case DIKS_CURSOR_LEFT: mplayer_put_key(KEY_LEFT);break;
 917                                 case DIKS_CURSOR_RIGHT: mplayer_put_key(KEY_RIGHT);break;
 918                                 case DIKS_INSERT: mplayer_put_key(KEY_INSERT);break;
 919                                 case DIKS_DELETE: mplayer_put_key(KEY_DELETE);break;
 920                                 case DIKS_HOME: mplayer_put_key(KEY_HOME);break;
 921                                 case DIKS_END: mplayer_put_key(KEY_END);break;
 922
 923                 default:mplayer_put_key(event.key_symbol);
 924                 };
 925         };
 926     };
 927 // empty buffer, because of repeating (keyboard repeat is faster than key handling
 928 // and this causes problems during seek)
 929 // temporary workaround should be solved in the future
 930     buffer->Reset(buffer);
 931
 932 }
 933 //if ( mp_msg_test(MSGT_VO,MSGL_V) ) printf ("DirectFB: Check events finished\n");
 934 }
 935
 936 static void flip_page(void)
 937 {
 938         DFBSurfaceBlittingFlags flags=DSBLIT_NOFX;
 939
 940         unlock(); // unlock frame & primary
 941
 942 //      if ( mp_msg_test(MSGT_VO,MSGL_V) ) printf("DirectFB: Flip page entered");
 943
 944         DFBCHECK (primary->SetBlittingFlags(primary,flags));
 945
 946         if (frame) {
 947             if (stretch) {
 948                 DFBRectangle rect;
 949                 rect.x=xoffset;
 950                 rect.y=yoffset;
 951                 rect.w=out_width;
 952                 rect.h=out_height;
 953
 954                 DFBCHECK (primary->StretchBlit(primary,frame,NULL,&rect));
 955
 956             } else {
 957
 958                 DFBCHECK (primary->Blit(primary,frame,NULL,xoffset,yoffset));
 959
 960             };
 961         };
 962
 963
 964 #ifdef TRIPLE
 965     switch (flipping) {
 966             case 1: DFBCHECK (primary->Flip (primary, NULL, DSFLIP_WAIT));
 967                     break;
 968             case 2: DFBCHECK (primary->Flip (primary, NULL, DSFLIP_ONSYNC));
 969                     break;
 970             default:; // should never be reached
 971         }
 972 #else
 973     if (flipping) {
 974             DFBCHECK (primary->Flip (primary, NULL, DSFLIP_WAITFORSYNC));
 975         }
 976 #endif
 977
 978 }
 979
 980
 981
 982 static void uninit(void)
 983 {
 984
 985   //mp_msg(MSGT_VO, MSGL_INFO,"DirectFB: Uninit entered\n");
 986
 987   unlock();
 988
 989   /*
 990    * (Release)
 991    */
 992 /*
 993   mp_msg(MSGT_VO, MSGL_INFO,"DirectFB: Releasing buffer\n");
 994   if (buffer) buffer->Release (buffer);
 995   mp_msg(MSGT_VO, MSGL_INFO,"DirectFB: Releasing keyboard\n");
 996   if (keyboard) keyboard->Release (keyboard);
 997 */
 998   if (frame) {
 999     mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Releasing frame\n");
1000     frame->Release (frame);
1001     frame = NULL;
1002   };
1003
1004 //  switch off BES
1005 //  if (layer) layer->SetOpacity(layer,0);
1006
1007   if (layer) {
1008    mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Releasing layer\n");
1009    layer->Release(layer);
1010    layer = NULL;
1011   }
1012
1013   if (primary) {
1014    mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: Releasing primary\n");
1015    primary->Release (primary);
1016    primary = NULL;
1017   }
1018
1019
1020 /*  mp_msg(MSGT_VO, MSGL_INFO,"DirectFB: Releasing DirectFB library\n");
1021
1022   dfb->Release (dfb);
1023 */
1024   //mp_msg(MSGT_VO, MSGL_INFO,"DirectFB: Uninit done.\n");
1025 }
1026
1027
1028 static uint32_t directfb_set_video_eq(char *data, int value) //data==name
1029 {
1030
1031         DFBColorAdjustment ca;
1032         float factor =  (float)0xffff / 200.0;
1033
1034         DFBDisplayLayerDescription  desc;
1035
1036         unlock();
1037
1038 if (layer) {
1039
1040         layer->GetDescription(layer,&desc);
1041
1042         ca.flags=DCAF_NONE;
1043
1044         if (! strcmp( data,"brightness" )) {
1045             if (desc.caps & DLCAPS_BRIGHTNESS) {
1046                 ca.brightness = value * factor +0x8000;
1047                 ca.flags |= DCAF_BRIGHTNESS;
1048                 mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: SetVEq Brightness 0x%X %i\n",ca.brightness,value);
1049             } else return VO_FALSE;
1050         }
1051
1052         if (! strcmp( data,"contrast" )) {
1053             if ((desc.caps & DLCAPS_CONTRAST)) {
1054                 ca.contrast = value * factor + 0x8000;
1055                 ca.flags |= DCAF_CONTRAST;
1056                 mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: SetVEq Contrast 0x%X %i\n",ca.contrast,value);
1057             } else return VO_FALSE;
1058         }
1059
1060         if (! strcmp( data,"hue" )) {
1061             if ((desc.caps & DLCAPS_HUE)) {
1062                 ca.hue = value * factor + 0x8000;
1063                 ca.flags |= DCAF_HUE;
1064                 mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: SetVEq Hue 0x%X %i\n",ca.hue,value);
1065             } else return VO_FALSE;
1066         }
1067
1068         if (! strcmp( data,"saturation" )) {
1069                 if ((desc.caps & DLCAPS_SATURATION)) {
1070                 ca.saturation = value * factor + 0x8000;
1071                 ca.flags |= DCAF_SATURATION;
1072                 mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: SetVEq Saturation 0x%X %i\n",ca.saturation,value);
1073             } else return VO_FALSE;
1074         }
1075
1076         if (ca.flags != DCAF_NONE) {
1077             layer->SetColorAdjustment(layer,&ca);
1078             return VO_TRUE;
1079         }
1080 }
1081
1082     return VO_FALSE;
1083
1084 }
1085
1086 static uint32_t directfb_get_video_eq(char *data, int *value) // data==name
1087 {
1088
1089         DFBColorAdjustment ca;
1090         float factor = 200.0 / (float)0xffff;
1091
1092         DFBDisplayLayerDescription desc;
1093
1094 if (layer) {
1095
1096         unlock();
1097
1098         layer->GetDescription(layer,&desc);
1099
1100         layer->GetColorAdjustment(layer,&ca);
1101
1102         if (! strcmp( data,"brightness" )) {
1103             if (desc.caps & DLCAPS_BRIGHTNESS) {
1104                 *value = (int) ((ca.brightness-0x8000) * factor);
1105                 mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: GetVEq Brightness 0x%X %i\n",ca.brightness,*value);
1106                 return VO_TRUE;
1107             } else return VO_FALSE;
1108         }
1109
1110         if (! strcmp( data,"contrast" )) {
1111             if ((desc.caps & DLCAPS_CONTRAST)) {
1112                 *value = (int) ((ca.contrast-0x8000) * factor);
1113                 mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: GetVEq Contrast 0x%X %i\n",ca.contrast,*value);
1114                 return VO_TRUE;
1115             } else return VO_FALSE;
1116         }
1117
1118         if (! strcmp( data,"hue" )) {
1119             if ((desc.caps & DLCAPS_HUE)) {
1120                 *value = (int) ((ca.hue-0x8000) * factor);
1121                 mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: GetVEq Hue 0x%X %i\n",ca.hue,*value);
1122                 return VO_TRUE;
1123             } else return VO_FALSE;
1124         }
1125
1126         if (! strcmp( data,"saturation" )) {
1127             if ((desc.caps & DLCAPS_SATURATION)) {
1128                 *value = (int) ((ca.saturation-0x8000) * factor);
1129                 mp_msg(MSGT_VO, MSGL_DBG2,"DirectFB: GetVEq Saturation 0x%X %i\n",ca.saturation,*value);
1130                 return VO_TRUE;
1131             } else return VO_FALSE;
1132         }
1133 }
1134     return VO_FALSE;
1135 }
1136
1137 static uint32_t get_image(mp_image_t *mpi)
1138 {
1139
1140         int err;
1141         uint8_t *dst;
1142         int pitch;
1143
1144 //    if ( mp_msg_test(MSGT_VO,MSGL_V) ) printf("DirectFB: get_image() called\n");
1145     if(mpi->flags&MP_IMGFLAG_READABLE) return VO_FALSE; // slow video ram
1146     if(mpi->type==MP_IMGTYPE_STATIC) return VO_FALSE; // it is not static
1147
1148 //    printf("width=%d vs. pitch=%d, flags=0x%X  \n",mpi->width,pitch,mpi->flags);
1149
1150     if(mpi->flags&(MP_IMGFLAG_ACCEPT_STRIDE|MP_IMGFLAG_ACCEPT_WIDTH)){
1151        // we're lucky or codec accepts stride => ok, let's go!
1152
1153             if (frame) {
1154                 err = frame->Lock(frame,DSLF_WRITE|DSLF_READ,(void *)&dst,&pitch);
1155                 framelocked=1;
1156             } else {
1157                 err = primary->Lock(primary,DSLF_WRITE,(void *)&dst,&pitch);
1158                 primarylocked=1;
1159             }
1160
1161             if (err) {
1162                 mp_msg(MSGT_VO, MSGL_ERR,"DirectFB: DR lock failed!");
1163                 return VO_FALSE;
1164             };
1165
1166        if(mpi->flags&MP_IMGFLAG_PLANAR){
1167            //YV12 format
1168            mpi->planes[0]=dst;
1169            if(mpi->flags&MP_IMGFLAG_SWAPPED){
1170            mpi->planes[1]=dst + pitch*height;
1171            mpi->planes[2]=mpi->planes[1] + pitch*height/4;
1172            } else {
1173            mpi->planes[2]=dst + pitch*height;
1174            mpi->planes[1]=mpi->planes[2] + pitch*height/4;
1175            }
1176            mpi->width=width;
1177            mpi->stride[0]=pitch;
1178            mpi->stride[1]=mpi->stride[2]=pitch/2;
1179        } else {
1180            //YUY2 and RGB formats
1181            mpi->planes[0]=dst;
1182            mpi->width=width;
1183            mpi->stride[0]=pitch;
1184        }
1185
1186        // center image
1187
1188        if (!frame) {
1189             if(mpi->flags&MP_IMGFLAG_PLANAR){
1190                 mpi->planes[0]= dst + yoffset * pitch + xoffset;
1191                 mpi->planes[1]+= ((yoffset * pitch) >> 2) + (xoffset >> 1);
1192                 mpi->planes[2]+= ((yoffset * pitch) >> 2) + (xoffset >> 1);
1193             } else {
1194                 mpi->planes[0]=dst + yoffset * pitch + xoffset * (mpi->bpp >> 3);
1195             }
1196        }
1197
1198        mpi->flags|=MP_IMGFLAG_DIRECT;
1199 //       if ( mp_msg_test(MSGT_VO,MSGL_V) ) printf("DirectFB: get_image() SUCCESS -> Direct Rendering ENABLED\n");
1200        return VO_TRUE;
1201
1202     }
1203     return VO_FALSE;
1204 }
1205
1206 static int draw_slice(uint8_t *src[], int stride[], int w, int h, int x, int y)
1207 {
1208         int i;
1209         unsigned int pitch;
1210         uint8_t *dst;
1211         uint8_t *dst2;
1212         uint8_t *srcp;
1213         unsigned int p;
1214
1215 //        if ( mp_msg_test(MSGT_VO,MSGL_V) ) printf("DirectFB: draw_slice entered\n");
1216
1217         unlock();
1218
1219         if (frame) {
1220                 DFBCHECK (frame->Lock(frame,DSLF_WRITE|DSLF_READ,(void *)&dst,&pitch));
1221                 framelocked = 1;
1222         } else {
1223                 DFBCHECK (primary->Lock(primary,DSLF_WRITE,(void *)&dst,&pitch));
1224                 primarylocked = 1;
1225         };
1226
1227         p=min(w,pitch);
1228
1229         dst += y*pitch + x;
1230         dst2 = dst + pitch*height - y*pitch + y*pitch/4 - x/2;
1231         srcp = src[0];
1232
1233         for (i=0;i<h;i++) {
1234             fast_memcpy(dst,srcp,p);
1235             dst += pitch;
1236             srcp += stride[0];
1237         }
1238
1239         if (pixel_format == DSPF_YV12) {
1240
1241             dst = dst2;
1242             srcp = src[2];
1243             p = p/2;
1244
1245             for (i=0;i<h/2;i++) {
1246                 fast_memcpy(dst,srcp,p);
1247                 dst += pitch/2;
1248                 srcp += stride[2];
1249             }
1250
1251             dst = dst2 + pitch*height/4;
1252             srcp = src[1];
1253
1254             for (i=0;i<h/2;i++) {
1255                 fast_memcpy(dst,srcp,p);
1256                 dst += pitch/2;
1257                 srcp += stride[1];
1258             }
1259
1260         } else {
1261
1262             dst = dst2;
1263             srcp = src[1];
1264             p = p/2;
1265
1266             for (i=0;i<h/2;i++) {
1267                 fast_memcpy(dst,srcp,p);
1268                 dst += pitch/2;
1269                 srcp += stride[1];
1270             }
1271
1272             dst = dst2 + pitch*height/4;
1273             srcp = src[2];
1274
1275             for (i=0;i<h/2;i++) {
1276                 fast_memcpy(dst,srcp,p);
1277                 dst += pitch/2;
1278                 srcp += stride[2];
1279             }
1280
1281         }
1282
1283         unlock();
1284
1285     return 0;
1286 }
1287
1288
1289 static uint32_t put_image(mp_image_t *mpi){
1290
1291
1292 //    static IDirectFBSurface *tmp = NULL;
1293 //    DFBSurfaceDescription dsc;
1294 //    DFBRectangle rect;
1295
1296 //    if ( mp_msg_test(MSGT_VO,MSGL_V) ) printf("DirectFB: Put_image entered %i %i %i %i %i %i\n",mpi->x,mpi->y,mpi->w,mpi->h,mpi->width,mpi->height);
1297
1298     unlock();
1299
1300     // already out?
1301     if((mpi->flags&(MP_IMGFLAG_DIRECT|MP_IMGFLAG_DRAW_CALLBACK))) {
1302 //        if ( mp_msg_test(MSGT_VO,MSGL_V) ) printf("DirectFB: Put_image - nothing to do\n");
1303         return VO_TRUE;
1304     }
1305
1306     if (mpi->flags&MP_IMGFLAG_PLANAR) {
1307     // memcpy all planes - sad but necessary
1308         int i;
1309         unsigned int pitch;
1310         uint8_t *dst;
1311         uint8_t *src;
1312         unsigned int p;
1313
1314 //        if ( mp_msg_test(MSGT_VO,MSGL_V) ) printf("DirectFB: Put_image - planar branch\n");
1315         if (frame) {
1316                 DFBCHECK (frame->Lock(frame,DSLF_WRITE|DSLF_READ,(void *)&dst,&pitch));
1317                 framelocked = 1;
1318         } else {
1319                 DFBCHECK (primary->Lock(primary,DSLF_WRITE,(void *)&dst,&pitch));
1320                 primarylocked = 1;
1321         };
1322
1323         p=min(mpi->w,pitch);
1324
1325         src = mpi->planes[0]+mpi->y*mpi->stride[0]+mpi->x;
1326
1327         for (i=0;i<mpi->h;i++) {
1328             fast_memcpy(dst+i*pitch,src+i*mpi->stride[0],p);
1329         }
1330
1331
1332         if (pixel_format == DSPF_YV12) {
1333
1334             dst += pitch*height;
1335             p = p/2;
1336             src = mpi->planes[2]+mpi->y*mpi->stride[2]+mpi->x/2;
1337
1338             for (i=0;i<mpi->h/2;i++) {
1339                 fast_memcpy(dst+i*pitch/2,src+i*mpi->stride[2],p);
1340             }
1341
1342             dst += pitch*height/4;
1343             src = mpi->planes[1]+mpi->y*mpi->stride[1]+mpi->x/2;
1344
1345             for (i=0;i<mpi->h/2;i++) {
1346                 fast_memcpy(dst+i*pitch/2,src+i*mpi->stride[1],p);
1347             }
1348
1349         } else {
1350
1351             dst += pitch*height;
1352             p = p/2;
1353             src = mpi->planes[1]+mpi->y*mpi->stride[1]+mpi->x/2;
1354
1355             for (i=0;i<mpi->h/2;i++) {
1356                 fast_memcpy(dst+i*pitch/2,src+i*mpi->stride[1],p);
1357             }
1358
1359             dst += pitch*height/4;
1360             src = mpi->planes[2]+mpi->y*mpi->stride[2]+mpi->x/2;
1361
1362             for (i=0;i<mpi->h/2;i++) {
1363                 fast_memcpy(dst+i*pitch/2,src+i*mpi->stride[2],p);
1364             }
1365
1366         }
1367         unlock();
1368
1369     } else {
1370 // I had to disable native directfb blit because it wasn't working under some conditions :-(
1371
1372 /*
1373         dsc.flags = DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_WIDTH | DSDESC_PREALLOCATED;
1374         dsc.preallocated[0].data = mpi->planes[0];
1375         dsc.preallocated[0].pitch = mpi->stride[0];
1376         dsc.width = mpi->width;
1377         dsc.height = mpi->height;
1378         dsc.pixelformat = convformat(mpi->imgfmt);
1379
1380         DFBCHECK (dfb->CreateSurface( dfb, &dsc, &tmp));
1381
1382         rect.x=mpi->x;
1383         rect.y=mpi->y;
1384         rect.w=mpi->w;
1385         rect.h=mpi->h;
1386
1387         if (frame) {
1388                 DFBCHECK (tmp->Blit(tmp,frame,&rect,0,0));
1389         } else {
1390                 DFBCHECK (tmp->Blit(tmp,primary,&rect,xoffset,yoffset));
1391         };
1392         tmp->Release(tmp);
1393 */
1394
1395         unsigned int pitch;
1396         uint8_t *dst;
1397
1398 //        if ( mp_msg_test(MSGT_VO,MSGL_V) ) printf("DirectFB: Put_image - non-planar branch\n");
1399         if (frame) {
1400                 DFBCHECK (frame->Lock(frame,DSLF_WRITE,(void *)&dst,&pitch));
1401                 framelocked = 1;
1402                 mem2agpcpy_pic(dst,mpi->planes[0] + mpi->y * mpi->stride[0] + mpi->x * (mpi->bpp >> 3)  ,mpi->w * (mpi->bpp >> 3),mpi->h,pitch,mpi->stride[0]);
1403         } else {
1404                 DFBCHECK (primary->Lock(primary,DSLF_WRITE,(void *)&dst,&pitch));
1405                 primarylocked = 1;
1406                 mem2agpcpy_pic(dst + yoffset * pitch + xoffset * (mpi->bpp >> 3),mpi->planes[0] + mpi->y * mpi->stride[0] + mpi->x * (mpi->bpp >> 3)  ,mpi->w * (mpi->bpp >> 3),mpi->h,pitch,mpi->stride[0]);
1407         };
1408         unlock();
1409
1410     }
1411     return VO_TRUE;
1412 }
1413
1414
1415
1416 static int control(uint32_t request, void *data, ...)
1417 {
1418   switch (request) {
1419     case VOCTRL_QUERY_FORMAT:
1420         return query_format(*((uint32_t*)data));
1421     case VOCTRL_GET_IMAGE:
1422         return get_image(data);
1423     case VOCTRL_DRAW_IMAGE:
1424         return put_image(data);
1425     case VOCTRL_SET_EQUALIZER:
1426       {
1427         va_list ap;
1428         int value;
1429
1430         va_start(ap, data);
1431         value = va_arg(ap, int);
1432         va_end(ap);
1433
1434         return directfb_set_video_eq(data, value);
1435       }
1436     case VOCTRL_GET_EQUALIZER:
1437       {
1438         va_list ap;
1439         int *value;
1440
1441         va_start(ap, data);
1442         value = va_arg(ap, int*);
1443         va_end(ap);
1444
1445         return directfb_get_video_eq(data, value);
1446       }
1447   };
1448   return VO_NOTIMPL;
1449 }
1450
1451 // unused function
1452
1453 static int draw_frame(uint8_t *src[])
1454 {
1455         return -1;
1456 }
1457
1458 // hopefully will be removed soon
1459
1460 static void draw_alpha(int x0, int y0, int w, int h, unsigned char *src,
1461                 unsigned char *srca, int stride)
1462 {
1463         void *dst;
1464         int pitch;
1465
1466         unlock(); // isn't it silly I have to unlock surface and then lock it again :-)
1467
1468         if (frame) {
1469                 DFBCHECK (frame->Lock(frame,DSLF_WRITE|DSLF_READ,&dst,&pitch));
1470                 framelocked = 1;
1471         } else {
1472                 DFBCHECK (primary->Lock(primary,DSLF_WRITE,&dst,&pitch));
1473                 primarylocked = 1;
1474         };
1475
1476         switch(pixel_format) {
1477                 case DSPF_RGB32:
1478                 case DSPF_ARGB:
1479                         vo_draw_alpha_rgb32(w,h,src,srca,stride,((uint8_t *) dst)+pitch*y0 + 4*x0,pitch);
1480                         break;
1481
1482                 case DSPF_RGB24:
1483                         vo_draw_alpha_rgb24(w,h,src,srca,stride,((uint8_t *) dst)+pitch*y0 + 3*x0,pitch);
1484                         break;
1485
1486                 case DSPF_RGB16:
1487                         vo_draw_alpha_rgb16(w,h,src,srca,stride,((uint8_t *) dst)+pitch*y0 + 2*x0,pitch);
1488                         break;
1489 #if DIRECTFBVERSION > DFB_VERSION(0,9,15)
1490                 case DSPF_ARGB1555:
1491 #else
1492                 case DSPF_RGB15:
1493 #endif
1494                         vo_draw_alpha_rgb15(w,h,src,srca,stride,((uint8_t *) dst)+pitch*y0 + 2*x0,pitch);
1495                         break;
1496
1497                 case DSPF_YUY2:
1498                         vo_draw_alpha_yuy2(w,h,src,srca,stride,((uint8_t *) dst) + pitch*y0 + 2*x0,pitch);
1499                 break;
1500
1501                 case DSPF_UYVY:
1502                         vo_draw_alpha_yuy2(w,h,src,srca,stride,((uint8_t *) dst) + pitch*y0 + 2*x0 + 1,pitch);
1503                 break;
1504
1505                 case DSPF_I420:
1506                 case DSPF_YV12:
1507                         vo_draw_alpha_yv12(w,h,src,srca,stride,((uint8_t *) dst) + pitch*y0 + 1*x0,pitch);
1508                 break;
1509                 }
1510
1511             unlock();
1512 }
1513
1514 static void draw_osd(void)
1515 {
1516     vo_draw_text(width,height,draw_alpha);
1517 }