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