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