osdopenvg.cc

   1 /*
   2     Copyright 2004-2005 Chris Tallon, 2006,2011-2012 Marten Richter
   3
   4     This file is part of VOMP.
   5
   6     VOMP is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     VOMP is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with VOMP; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19 */
  20
  21
  22 #include "osdopenvg.h"
  23 #include "mtd.h"
  24 #include "videoomx.h"
  25 #include "surface.h"
  26 //#include <Magick++.h>
  27
  28 #include "message.h"
  29 #include "command.h"
  30 #include "teletxt/txtfont.h"
  31
  32 #include <sys/syscall.h>
  33 #include <fontconfig/fontconfig.h>
  34 #include <vector>
  35 #include <math.h>
  36 #include <bcm_host.h>
  37
  38 //using namespace Magick;
  39
  40 extern uint8_t vdr_data[]     asm("_binary_other_vdrhires_jpg_start");
  41 extern uint8_t vdr_data_end[] asm("_binary_other_vdrhires_jpg_end");
  42 extern uint8_t wallpaper_data[]     asm("_binary_other_wallpaper720p_jpg_start");
  43 extern uint8_t wallpaper_data_end[] asm("_binary_other_wallpaper720p_jpg_end");
  44
  45
  46 #define  BACKBUFFER_WIDTH 1280
  47 #define  BACKBUFFER_HEIGHT 720
  48
  49
  50 OsdOpenVG::OsdOpenVG()
  51 {
  52   vgmutex.Lock();
  53   taskmutex.Lock();
  54   lastrendertime=getTimeMS();
  55   display_height=0;
  56   display_width=0;
  57   mode=0;
  58   aspect_correction=1.;
  59
  60   freetype_inited=false;
  61   wait_id=1;
  62   const char *fontname="Droid Sans:style=Regular";
  63   cur_fontname=(char*)malloc(strlen(fontname)+1);
  64   strcpy(cur_fontname,fontname);
  65
  66 }
  67
  68 OsdOpenVG::~OsdOpenVG()
  69 {
  70
  71   if (initted)
  72   {
  73                 shutdown();
  74   }
  75
  76   if (cur_fontname) free(cur_fontname);
  77   if (freetype_inited) FT_Done_Face(ft_face);
  78   if (!fontnames.size()) {
  79           vector<char*>::iterator itty=fontnames.begin();
  80           while (itty!=fontnames.end()) {
  81                   free((void*)*itty);
  82
  83                   itty++;
  84           }
  85   }
  86   if (!fontnames_keys.size()) {
  87           vector<char*>::iterator itty=fontnames_keys.begin();
  88           while (itty!=fontnames_keys.end()) {
  89                   free((void*)*itty);
  90
  91                   itty++;
  92           }
  93     }
  94
  95   vgmutex.Unlock();
  96   taskmutex.Unlock();
  97 }
  98
  99
 100
 101 int OsdOpenVG::init(void* device)
 102 {
 103   if (initted) return 0;
 104   reader.init();
 105   Video* video = Video::getInstance();
 106    //window=*((HWND*)device);
 107
 108    // May be this device specific part should go to a device specific child class
 109
 110    //init broadcom chipset (Move to video?)
 111
 112
 113    //First get connection to egl
 114    egl_display=eglGetDisplay(EGL_DEFAULT_DISPLAY);
 115
 116    if (egl_display==EGL_NO_DISPLAY) {
 117            Log::getInstance()->log("OSD", Log::WARN, "Could not get egl display! %x",eglGetError());
 118            vgmutex.Unlock();
 119            return 0;
 120    }
 121
 122
 123
 124    if (eglInitialize(egl_display, NULL, NULL)==EGL_FALSE) {
 125            Log::getInstance()->log("OSD", Log::WARN, "Initialising display failed! %x",eglGetError());
 126            vgmutex.Unlock();
 127            return 0;
 128    }
 129
 130
 131    const char *query_str=eglQueryString(egl_display,EGL_CLIENT_APIS);
 132    if (query_str) Log::getInstance()->logLongString("OSD", Log::NOTICE, query_str);
 133    else Log::getInstance()->log("OSD", Log::WARN, "Could not query display %x",eglGetError());
 134    query_str=eglQueryString(egl_display,EGL_EXTENSIONS);
 135    if (query_str)    Log::getInstance()->logLongString("OSD", Log::NOTICE, query_str);
 136    else Log::getInstance()->log("OSD", Log::WARN, "Could not query display %x",eglGetError());
 137
 138    if (eglBindAPI(EGL_OPENVG_API)==EGL_FALSE) {
 139            Log::getInstance()->log("OSD", Log::WARN, "Binding openvg api failed! %x",eglGetError());
 140            vgmutex.Unlock();
 141            return 0;
 142    }
 143
 144    const EGLint attributs[]={
 145                  EGL_RED_SIZE,8,EGL_GREEN_SIZE, 8,EGL_BLUE_SIZE, 8,EGL_ALPHA_SIZE, 8,
 146          EGL_SURFACE_TYPE, EGL_WINDOW_BIT|EGL_PBUFFER_BIT,
 147          EGL_CONFORMANT, EGL_OPENVG_BIT,
 148          EGL_NONE
 149    }; // Here, we might have to select the resolution!
 150
 151
 152    EGLint number;
 153
 154    if (eglChooseConfig(egl_display, attributs, &egl_ourconfig, 1, &number)==EGL_FALSE) {
 155            Log::getInstance()->log("OSD", Log::WARN, "Choosing egl config failed! %x",eglGetError());
 156            vgmutex.Unlock();
 157            return 0;
 158    }
 159
 160
 161
 162    egl_context=eglCreateContext(egl_display,egl_ourconfig,NULL,NULL);
 163    if (egl_context==EGL_NO_CONTEXT) {
 164            Log::getInstance()->log("OSD", Log::WARN, "Creating egl context failed! %x",eglGetError());
 165            vgmutex.Unlock();
 166            return 0;
 167    }
 168
 169    // warning broadcom specific, get display size!
 170    display_width=display_height=0;
 171    if (graphics_get_display_size(0, &display_width, &display_height)<0) {
 172            Log::getInstance()->log("OSD", Log::WARN, "Getting display size failed! (BCM API) ");
 173            vgmutex.Unlock();
 174            return 0;
 175    }
 176    Log::getInstance()->log("OSD", Log::NOTICE, "Displaysize is %d x %d ",display_width, display_height);
 177    VC_RECT_T dst_rect ={0,0,display_width,display_height};
 178    VC_RECT_T src_rect={0,0,BACKBUFFER_WIDTH <<16,BACKBUFFER_HEIGHT<<16};
 179    VC_RECT_T src_rect_bg={0,0,16<<16,16<<16};
 180    VC_RECT_T src_rect_im={0,0,16,16};
 181
 182    uint32_t back_image_ptr;
 183    bcm_backres=vc_dispmanx_resource_create(VC_IMAGE_RGBX32,16,16,&back_image_ptr);
 184    unsigned int color[16*16];
 185    DrawStyle bg=DrawStyle::WALLPAPER;
 186    if (bg.ft!=DrawStyle::GradientLinear) {
 187            bg.grad_col[0]=bg;
 188    }
 189    //memset(color,0xFF,sizeof(unsigned int)*4*8);
 190    for (int j=0;j<16;j++) {
 191            int helpr=(((15-j)*bg.red)+(j*bg.grad_col[0].red))/15;
 192            int helpb=(((15-j)*bg.blue)+(j*bg.grad_col[0].blue))/15;
 193            int helpg=(((15-j)*bg.green)+(j*bg.grad_col[0].green))/15;
 194            //unsigned int cur_col=help | (help<< 8)  | (help<< 16)  | (0xFF<< 24);
 195            unsigned int cur_col=helpr  | (helpg<< (8))  | (helpb<< (16))  | (0xFF<< (24));
 196            for (int i=0;i<16;i++) {
 197                    color[i+16*j]=cur_col;
 198            }
 199    }
 200    vc_dispmanx_resource_write_data(bcm_backres,VC_IMAGE_RGBX32,16*4,color,&src_rect_im);
 201
 202    DISPMANX_UPDATE_HANDLE_T  bcm_update;
 203    bcm_display=vc_dispmanx_display_open(0);
 204    bcm_update=vc_dispmanx_update_start(0);
 205    bcm_element=vc_dispmanx_element_add(bcm_update,bcm_display,
 206          2,&dst_rect, 0,
 207          &src_rect,DISPMANX_PROTECTION_NONE,0, 0, (DISPMANX_TRANSFORM_T) 0);
 208
 209
 210    bcm_background=vc_dispmanx_element_add(bcm_update,bcm_display,
 211             0,&dst_rect,bcm_backres ,
 212             &src_rect_bg,DISPMANX_PROTECTION_NONE,0, 0, (DISPMANX_TRANSFORM_T) 0);
 213
 214    vc_dispmanx_update_submit_sync(bcm_update);
 215
 216
 217
 218    static EGL_DISPMANX_WINDOW_T nativewindow;
 219    nativewindow.element=bcm_element;
 220    nativewindow.height=BACKBUFFER_HEIGHT;
 221    nativewindow.width=BACKBUFFER_WIDTH;
 222
 223    egl_surface = eglCreateWindowSurface(egl_display,egl_ourconfig, &nativewindow,NULL );
 224    if (egl_surface==EGL_NO_SURFACE) {
 225            Log::getInstance()->log("OSD", Log::WARN, "Creating egl window surface failed!");
 226            vgmutex.Unlock();
 227            return 0;
 228    }
 229    Log::getInstance()->log("OSD", Log::DEBUG, "Making egl current in1%d",syscall(SYS_gettid));
 230    if (eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context)== EGL_FALSE) {
 231            Log::getInstance()->log("OSD", Log::WARN, "Making egl Current failed");
 232            vgmutex.Unlock();
 233                    return 0;
 234    }
 235    // Test stuff
 236
 237    query_str=(const char*)vgGetString(VG_VERSION) ;
 238    if (query_str) Log::getInstance()->logLongString("OSD", Log::NOTICE, query_str);
 239    else Log::getInstance()->log("OSD", Log::WARN, "Could not query display %x",vgGetError());
 240
 241    query_str=(const char*)vgGetString(VG_VENDOR) ;
 242    if (query_str) Log::getInstance()->logLongString("OSD", Log::NOTICE, query_str);
 243    else Log::getInstance()->log("OSD", Log::WARN, "Could not query display %x",vgGetError());
 244
 245    query_str=(const char*)vgGetString(VG_RENDERER) ;
 246    if (query_str) Log::getInstance()->logLongString("OSD", Log::NOTICE, query_str);
 247    else Log::getInstance()->log("OSD", Log::WARN, "Could not query display %x",vgGetError());
 248
 249    query_str=(const char*)vgGetString(VG_EXTENSIONS) ;
 250    if (query_str) Log::getInstance()->logLongString("OSD", Log::NOTICE, query_str);
 251    else Log::getInstance()->log("OSD", Log::WARN, "Could not query display %x",vgGetError());
 252
 253   aspect_correction= ((float)BACKBUFFER_HEIGHT)/576.f/(((float)BACKBUFFER_WIDTH)/720.f);
 254   initPaths();
 255   if (!fontnames.size()) {
 256           //inspired by and copied from vdr's code
 257           FcInit();
 258           FcObjectSet *objset= FcObjectSetBuild(FC_FAMILY, FC_STYLE, NULL);
 259           FcPattern * pattern=FcPatternCreate();
 260           FcPatternAddBool(pattern, FC_SCALABLE, FcTrue);
 261           FcFontSet* fonts = FcFontList(NULL, pattern, objset);
 262           for (int i=0; i<fonts->nfont;i++) {
 263                   char *s = (char *)FcNameUnparse(fonts->fonts[i]);
 264
 265                   if (s) {
 266                           char *c= strchr(s,':');
 267                           if (c) {
 268                                   char *s2= strchr(c+1,',');
 269                                   if (s2) *s2=0;
 270                           }
 271                           char *p=strchr(s,',');
 272                           if (p) {
 273                                   if (!c) *p=0;
 274                                   else memmove(p,c,strlen(c)+1);
 275                           }
 276                           char *key=(char*)malloc(strlen(s)+1);
 277                           strcpy(key,s);
 278                           fontnames_keys.push_back(key);
 279                           char *s2=strstr(s,"style=");
 280                           if (s2) {
 281                                   memmove(s2,s2+6,strlen(s2+6)+1);
 282                           }
 283                           fontnames.push_back(s);
 284                   }
 285           }
 286           FcFontSetDestroy(fonts);
 287           FcPatternDestroy(pattern);
 288           FcObjectSetDestroy(objset);
 289   }
 290
 291   if (!loadFont(false)) {
 292           return 0;
 293   }
 294   vgttfont=vgCreateFont(0);
 295   vgttpaint=vgCreatePaint();
 296   vgSetParameteri( vgttpaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
 297   vgSetColor(vgttpaint,0xffffffff);
 298
 299   eglSwapInterval(egl_display, 1 );
 300
 301   Log::getInstance()->log("OSD", Log::DEBUG, "Making egl current out 1%d",syscall(SYS_gettid));
 302   eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );
 303   //Now we will create the Screen
 304   initted = 1; // must set this here or create surface won't work
 305
 306
 307   /*if (((VideoOMX*)Video::getInstance())->initUsingOSDObjects()!=1) { //call Video for init  stuff
 308           return 0;
 309   }*/
 310
 311
 312   threadStart();
 313   taskmutex.Unlock();
 314   vgmutex.Unlock();
 315
 316 #ifdef PICTURE_DECODER_OMX
 317     imageomx=new ImageOMX(&reader);
 318         reader.addDecoder(imageomx);
 319 #endif
 320
 321
 322   return 1;
 323 }
 324
 325 void OsdOpenVG::getScreenSize(int &width, int &height)
 326 {
 327         width=BACKBUFFER_WIDTH;
 328         height=BACKBUFFER_HEIGHT;
 329 }
 330
 331
 332 void OsdOpenVG::initPaths()
 333 {
 334
 335
 336         VGPath current;
 337         current=vgCreatePath(VG_PATH_FORMAT_STANDARD,
 338                         VG_PATH_DATATYPE_F,1.f,0.f,
 339                         0,0,VG_PATH_CAPABILITY_ALL);
 340
 341         vguLine(current,0.f,0.f,1.f,0.f);
 342         // HorzLine
 343         std_paths[HorzLine]=current;
 344
 345         current=vgCreatePath(VG_PATH_FORMAT_STANDARD,
 346                                 VG_PATH_DATATYPE_F,1.f,0.f,
 347                                 0,0,VG_PATH_CAPABILITY_ALL);
 348         vguLine(current,0.f,0.f,0.f,1.f);
 349         // VertLine
 350         std_paths[VertLine]=current;
 351
 352         current=vgCreatePath(VG_PATH_FORMAT_STANDARD,
 353                                 VG_PATH_DATATYPE_F,1.f,0.f,
 354                                 0,0,VG_PATH_CAPABILITY_ALL);
 355         //vguRect(current,0.f,0.f,1.f,1.f);
 356         vguRect(current,0.f,0.f,1.f,1.f);
 357         // Rectabgle
 358         std_paths[Rectangle]=current;
 359
 360         current=vgCreatePath(VG_PATH_FORMAT_STANDARD,
 361                                 VG_PATH_DATATYPE_F,1.f,0.f,
 362                                 0,0,0);
 363         vguEllipse(current,0.f,0.f,1.f,1.f);
 364         // Point
 365         std_paths[Point]=current;
 366
 367 }
 368
 369 void OsdOpenVG::destroyPaths()
 370 {
 371         vgDestroyPath(std_paths[HorzLine]);
 372         vgDestroyPath(std_paths[VertLine]);
 373         vgDestroyPath(std_paths[Rectangle]);
 374         vgDestroyPath(std_paths[Point]);
 375
 376 }
 377
 378 int OsdOpenVG::stopUpdate()
 379 {
 380         threadStop();
 381         processTasks();
 382         return 1;
 383 }
 384 /*
 385 void OsdOpenVG::purgeAllReferences()
 386 {
 387         images_ref.clear();
 388         styles_ref.clear(); // remove all references
 389
 390
 391         map<void *,ImageIndex>::iterator mitty=monobitmaps.begin();
 392         while (mitty!=monobitmaps.end()) {
 393                 vgDestroyImage((VGImage)(*mitty).second);
 394                 mitty++;
 395         }
 396         monobitmaps.clear();
 397
 398         /*map<string,ImageIndex>::iterator jitty=jpegs.begin();
 399         while (jitty!=jpegs.end()) {
 400                 vgDestroyImage((VGImage)(*jitty).second);
 401                 jitty++;
 402         }
 403         jpegs.clear();*
 404
 405         map<TVMediaInfo,ImageIndex>::iterator titty=tvmedias.begin();
 406         while (titty!=tvmedias.end()) {
 407                 vgDestroyImage((VGImage)(*titty).second);
 408                 titty++;
 409         }
 410         tvmedias.clear();
 411
 412         map<pair<Colour*,unsigned int>,unsigned int>::iterator sitty=styles.begin();
 413         while (sitty!=styles.end()) {
 414                 vgDestroyPaint((VGPaint)(*sitty).second);
 415                 sitty++;
 416         }
 417         styles.clear();
 418
 419 }*/
 420
 421 int OsdOpenVG::shutdown()
 422 {
 423   reader.shutdown();
 424 #ifdef PICTURE_DECODER_OMX
 425         if (imageomx) reader.removeDecoder(imageomx);
 426         imageomx=NULL;
 427 #endif
 428
 429   if (!initted) return 0;
 430
 431   initted = 0;
 432   Log::getInstance()->log("OSD", Log::DEBUG, "shutdown mark1");
 433   threadStop();
 434   Log::getInstance()->log("OSD", Log::DEBUG, "shutdown mark1a");
 435   //(((VideoOMX*)Video::getInstance())->shutdownUsingOSDObjects());
 436   if (eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context)== EGL_FALSE) {
 437           Log::getInstance()->log("OSD", Log::WARN, "Making egl Current failed in shutdown %x",eglGetError());
 438   }
 439   if (eglBindAPI(EGL_OPENVG_API)==EGL_FALSE) {
 440           Log::getInstance()->log("OSD", Log::WARN, "Binding openvg api thread failed! %x",eglGetError());
 441   }
 442
 443   Log::getInstance()->log("OSD", Log::DEBUG, "shutdown mark2");
 444   processTasks();
 445   Log::getInstance()->log("OSD", Log::DEBUG, "shutdown mark3");
 446
 447   taskmutex.Lock();
 448   vgmutex.Lock();
 449
 450
 451
 452   //purgeAllReferences();
 453
 454   vgDestroyFont(vgfont);
 455   vgDestroyFont(vgttfont);
 456   vgDestroyPaint(vgttpaint);
 457   destroyPaths();
 458   float colclear[]={0.8f,0.8f,0.8f,1.f};
 459   vgSetfv(VG_CLEAR_COLOR,4,colclear);
 460   vgClear(0,0,BACKBUFFER_WIDTH,BACKBUFFER_HEIGHT);
 461   eglSwapBuffers(egl_display, egl_surface);
 462   Log::getInstance()->log("OSD", Log::DEBUG, "Making egl current out final");
 463   eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );
 464   if (eglDestroySurface(egl_display,egl_surface)==EGL_FALSE) {
 465           Log::getInstance()->log("OSD", Log::ERR, "eglDestroySurface failed %x",eglGetError());
 466   }
 467   if (eglDestroyContext(egl_display,egl_context)==EGL_FALSE) {
 468           Log::getInstance()->log("OSD", Log::ERR, "eglDestroyContext failed %x",eglGetError());
 469   }
 470   if (eglTerminate(egl_display )==EGL_FALSE) {
 471           Log::getInstance()->log("OSD", Log::ERR, "eglTerminate failed %x",eglGetError());
 472   }
 473
 474   DISPMANX_UPDATE_HANDLE_T  bcm_update;
 475   bcm_update=vc_dispmanx_update_start(0);
 476
 477   vc_dispmanx_element_remove(bcm_update,bcm_element);
 478   vc_dispmanx_element_remove(bcm_update,bcm_background);
 479   vc_dispmanx_update_submit_sync(bcm_update);
 480   vc_dispmanx_resource_delete(bcm_backres);
 481   vc_dispmanx_display_close(bcm_display);
 482
 483
 484
 485   return 1;
 486 }
 487
 488
 489
 490
 491 void OsdOpenVG::threadMethod()
 492 {
 493         // We have to claim the egl context for this thread
 494         Log::getInstance()->log("OSD", Log::NOTICE, "Entering drawing thread");
 495         if (eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context)== EGL_FALSE) {
 496                 Log::getInstance()->log("OSD", Log::WARN, "Making egl Current failed in thread %x",eglGetError());
 497                 return;
 498         }
 499         if (eglBindAPI(EGL_OPENVG_API)==EGL_FALSE) {
 500                 Log::getInstance()->log("OSD", Log::WARN, "Binding openvg api thread failed! %x",eglGetError());
 501                 return;
 502         }
 503         int ts=0;
 504         while (true)
 505         {
 506                 ts=1;
 507                 unsigned int waittime=1;
 508
 509                 if (initted) {
 510
 511                         long long time1 = getTimeMS();
 512                         if ((time1 - lastrendertime) > 200) {//5 fps for OSD updates are enough, avoids tearing
 513                                 InternalRendering();
 514                                 lastrendertime = getTimeMS();
 515
 516                         }
 517                         if (processTasks()) ts=0;
 518                 }
 519                 if (!threadIsActive()) {
 520                         if (eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT )== EGL_FALSE) {
 521                                    Log::getInstance()->log("OSD", Log::WARN, "Making egl Current out thread failed");
 522                         }
 523                         threadCheckExit();
 524                 }
 525                 if (ts!=0) {
 526                         struct timespec target_time;
 527                         clock_gettime(CLOCK_REALTIME,&target_time);
 528                         target_time.tv_nsec+=1000000LL*ts;
 529                         if (target_time.tv_nsec>999999999) {
 530                                 target_time.tv_nsec-=1000000000L;
 531                                 target_time.tv_sec+=1;
 532                         }
 533                         threadLock();
 534                         threadWaitForSignalTimed(&target_time);
 535                         threadUnlock();
 536                 }
 537                 //Sleep(1);
 538         }
 539         eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );
 540 }
 541
 542
 543 void OsdOpenVG::threadPostStopCleanup()
 544 {
 545         //Doing nothing
 546         //goo;
 547         Log::getInstance()->log("OSD", Log::NOTICE, "Exiting drawing thread");
 548 }
 549
 550 void OsdOpenVG::InternalRendering(){
 551         vgmutex.Lock();
 552         Colour bg=DrawStyle::WALLPAPER;
 553     float colclear[]={1.f,1.0f,1.f,1.f};
 554     if (bg.alpha==0) colclear[3]=0.f;
 555     vgSetfv(VG_CLEAR_COLOR,4,colclear);
 556         vgClear(0,0,BACKBUFFER_WIDTH,BACKBUFFER_HEIGHT);
 557         vgSeti(VG_BLEND_MODE, VG_BLEND_SRC);
 558
 559
 560         drawSurfaces(); //iterate through and draws all commands
 561
 562         //Show it to the user!
 563         eglSwapBuffers(egl_display, egl_surface);
 564         vgmutex.Unlock();
 565
 566 }
 567
 568 /*font stuff*/
 569
 570 float OsdOpenVG::getFontHeight()
 571 {
 572         return font_height; //dummy
 573 }
 574 float OsdOpenVG::getCharWidth(wchar_t c)
 575 {
 576         unsigned int glyph_index=FT_Get_Char_Index(ft_face,c);
 577         return font_exp_x[glyph_index];
 578 }
 579
 580 unsigned int OsdOpenVG::loadTTchar(cTeletextChar c)
 581 {
 582         unsigned int glyph_index=c.getGlyphIndex();
 583         if (tt_font_chars.find(glyph_index)!=tt_font_chars.end())
 584         {
 585                 return glyph_index;
 586         }
 587
 588         unsigned int buffer[10];
 589         const VGfloat glyphOrigin[] = { 0.f, 0.f };
 590         const VGfloat escapement[] = { 12.f, 0.f };
 591         unsigned int * charmap = GetFontChar(c, buffer);
 592         if (!charmap) { //invalid char
 593                 return 0;
 594         }
 595         for (int i=0;i<10;i++) {
 596                 buffer[i]=charmap[i]>>4;
 597         }
 598
 599         VGImage handle = vgCreateImage(
 600                         VG_A_8,
 601                         12,
 602                         10,
 603                         VG_IMAGE_QUALITY_NONANTIALIASED | VG_IMAGE_QUALITY_FASTER
 604                                         | VG_IMAGE_QUALITY_BETTER);
 605         vgImageSubData(handle, buffer, 4, VG_A_1, 0, 0, 12, 10);
 606         vgSetGlyphToImage(
 607                         vgttfont,
 608                         glyph_index,
 609                         handle, (VGfloat*)glyphOrigin, (VGfloat*)escapement);
 610         vgDestroyImage(handle);
 611         tt_font_chars[glyph_index]=1;
 612
 613         return glyph_index;
 614 }
 615
 616 int OsdOpenVG::getFontNames(const char *** names,const char *** names_keys)
 617 {
 618         *names=(const char**)&(fontnames[0]);
 619         *names_keys=(const char**)&(fontnames_keys[0]);
 620         return fontnames.size();
 621 }
 622
 623 void OsdOpenVG::setFont(const char * fontname) {
 624
 625         if (strcmp(fontname,cur_fontname)) {
 626                 // new font!
 627                 if (cur_fontname) free(cur_fontname);
 628                 cur_fontname=(char*)malloc(strlen(fontname)+1);
 629                 strcpy(cur_fontname,fontname);
 630
 631                 struct OpenVGCommand comm;
 632                 comm.task=OVGreplacefont;
 633                 putOpenVGCommand(comm,false);
 634
 635
 636         }
 637 }
 638
 639
 640 int  OsdOpenVG::loadFont(bool newfont)
 641 {
 642         int error;
 643         float font_size=16.f;
 644         if (!freetype_inited) {
 645                 error=FT_Init_FreeType(&ft_library);
 646                 if (error)
 647                 {
 648                         Log::getInstance()->log("OSD", Log::WARN, "Could not load freetype %x",error);
 649                         return 0;
 650                 }
 651         }
 652
 653         if (!freetype_inited || newfont) {
 654                 //first get the filename algorith extracted from vdr by Klaus Schmidinger
 655                 FcInit();
 656                 FcPattern *pattern=FcNameParse((FcChar8*)cur_fontname);
 657                 FcPatternAddBool(pattern,FC_SCALABLE,FcTrue);
 658                 FcConfigSubstitute(NULL,pattern,FcMatchPattern);
 659                 FcDefaultSubstitute(pattern);
 660                 FcResult fres;
 661                 FcFontSet *fonts=FcFontSort(NULL,pattern,FcFalse,NULL,&fres);
 662                 FcChar8 *filename=NULL;
 663                 if (fonts) {
 664                         for (int i=0;i<fonts->nfont;i++) {
 665                                 FcBool canscale;
 666                                 FcPatternGetBool(fonts->fonts[i],FC_SCALABLE,0,&canscale);
 667                                 if (canscale){
 668                                         FcPatternGetString(fonts->fonts[i],FC_FILE,0,&filename);
 669                                         break;
 670                                 }
 671                         }
 672                         FcFontSetDestroy(fonts);
 673                 } else {
 674                         Log::getInstance()->log("OSD", Log::CRIT, "Could not locate a font! Abort!");
 675                         return 0;
 676                 }
 677                 FcPatternDestroy(pattern);
 678
 679                 Log::getInstance()->log("OSD", Log::NOTICE, "Load Font %s: %s", cur_fontname,filename);
 680                 // second load the font
 681                 FT_Face     new_ft_face;
 682                 error=FT_New_Face(ft_library,(const char*)filename,0,&new_ft_face );
 683                 if (error) {
 684                         Log::getInstance()->log("OSD", Log::WARN, "Could not load font face %x %s",error,filename);
 685                         return 0;
 686                 }
 687                 error=FT_Set_Char_Size(new_ft_face,0,font_size*256,0,0 /*dpi*/);
 688                 if (error) {
 689                         FT_Done_Face(new_ft_face);
 690                         Log::getInstance()->log("OSD", Log::WARN, "Could not set  face size %x",error);
 691                         return 0;
 692                 }
 693                 FT_Face old_ft_face=ft_face; // do it thread safe
 694                 ft_face=new_ft_face;
 695                 if (freetype_inited) FT_Done_Face(old_ft_face);//
 696                 freetype_inited=true;
 697         }
 698         vgfont=vgCreateFont(0);
 699         FT_ULong cur_char;
 700         FT_UInt glyph;
 701         font_height=ft_face->size->metrics.height/256.f;
 702         cur_char = FT_Get_First_Char(ft_face,&glyph);
 703         vector<VGubyte> segments;
 704         vector<VGfloat> coord;
 705         segments.reserve(256);
 706         coord.reserve(1024);
 707         //Log::getInstance()->log("OSD", Log::DEBUG, "Create Glyph test %d %x %x %d",cur_char,font_data_end,font_data,glyph);
 708         while (glyph !=0)
 709         {
 710                 error=FT_Load_Glyph(ft_face,glyph,FT_LOAD_DEFAULT);
 711                 if (error){
 712                         FT_Done_Face(ft_face);
 713                         Log::getInstance()->log("OSD", Log::WARN, "Could not load glyph %x",error);
 714                         return 0;
 715                 }
 716                 VGPath path;
 717                 FT_Outline ot=ft_face->glyph->outline;
 718                 segments.clear();
 719                 coord.clear();
 720
 721                 if (ot.n_contours ==0) {
 722                         path=VG_INVALID_HANDLE;
 723                 } else {
 724                         path=vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F,
 725                                         1.0f,0.f,0,0,VG_PATH_CAPABILITY_ALL);
 726
 727                         /* convert glyph */
 728                         FT_Vector *pt=ot.points;
 729                         const char *tags=ot.tags;
 730                         const short* cont=ot.contours;
 731                         short n_cont=ot.n_contours;
 732                         short n_point=ot.n_points;
 733                         short last_cont=0;
 734                         for (short point=0;n_cont!=0;cont++,n_cont--) {
 735                                 short next_cont=*cont+1;
 736                                 bool first=true;
 737                                 char last_tag=0;
 738                                 short first_point=point;
 739                                 //Log::getInstance()->log("OSD", Log::DEBUG, "runs %d",*cont);
 740                                 for (;point<next_cont;point++) {
 741                                         char tag=tags[point];
 742                                         FT_Vector fpoint=pt[point];
 743                                 //      Log::getInstance()->log("OSD", Log::DEBUG, "tag %d point %d %d: %d %d",tag,fpoint.x,fpoint.y,point,n_point);
 744                                         if (first) {
 745                                                 segments.push_back(VG_MOVE_TO);
 746                                                 first=false;
 747                                         } else if (tag &0x1) { //on curve
 748                                                 if (last_tag &0x1) {
 749                                                         segments.push_back(VG_LINE_TO);
 750                                                 } else if (last_tag &0x2){
 751                                                         segments.push_back(VG_CUBIC_TO);
 752                                                 } else {
 753                                                         segments.push_back(VG_QUAD_TO);
 754                                                 }
 755
 756                                         } else {
 757                                                 if (!(tag &0x2)){
 758                                                         if (!(last_tag &0x1)) {
 759                                                                 segments.push_back(VG_QUAD_TO);
 760                                                                 int coord_size=coord.size();
 761                                                                 VGfloat x=(coord[coord_size-2]+ ((float)fpoint.x)/256.f)*0.5f*aspect_correction;
 762                                                                 VGfloat y=(coord[coord_size-1]+(font_size- ((float)fpoint.y)/256.f))*0.5f;
 763                                                                 coord.push_back(x);
 764                                                                 coord.push_back(y);
 765                                                         }
 766                                                 }
 767
 768
 769                                         }
 770                                         last_tag=tag;
 771                                         coord.push_back(((float)fpoint.x)*aspect_correction/256.);
 772                                         coord.push_back(font_size-((float)fpoint.y)/256.);
 773                                         //Log::getInstance()->log("OSD", Log::DEBUG, "Create APD Glyph coord %d %d %g %g",fpoint.x,fpoint.y,coord[coord.size()-2],coord[coord.size()-1]);
 774                                 }
 775                                 if (!(last_tag &0x1)) {
 776                                         if (last_tag &0x2) {
 777                                                 segments.push_back(VG_CUBIC_TO);
 778                                         } else {
 779                                                 segments.push_back(VG_QUAD_TO);
 780                                         }
 781                                         coord.push_back(((float)pt[first_point].x)*aspect_correction/256.);
 782                                         coord.push_back(font_size-((float)pt[first_point].y)/256.);
 783                                 }
 784                                 //segments.push_back(VG_CLOSE_PATH);
 785
 786
 787                         }
 788                         vgAppendPathData(path,segments.size(),&segments[0],&coord[0]);
 789                         int n=0;
 790                 /*      for (int m=0;m<segments.size();m++) {
 791                                 switch (segments[m])
 792                                 {
 793                                 case VG_MOVE_TO:
 794                                         Log::getInstance()->log("OSD", Log::DEBUG, "Move To %g %g",coord[n],coord[n+1]);n+=2; break;
 795                                 case VG_LINE_TO:
 796                                         Log::getInstance()->log("OSD", Log::DEBUG, "Line To %g %g",coord[n],coord[n+1]);n+=2; break;
 797                                 case VG_CUBIC_TO:
 798                                         Log::getInstance()->log("OSD", Log::DEBUG, "Cubic To %g %g %g %g %g %g",coord[n],coord[n+1],coord[n+2],coord[n+3],coord[n+4],coord[n+5]);n+=6; break;
 799                                 case VG_QUAD_TO:
 800                                         Log::getInstance()->log("OSD", Log::DEBUG, "Quad To %g %g %g %g",coord[n],coord[n+1],coord[n+2],coord[n+3]);n+=4; break;
 801                                 case VG_CLOSE_PATH:
 802                                         Log::getInstance()->log("OSD", Log::DEBUG, "Close Path"); break;
 803                                 }
 804
 805                         }*/
 806                         //vguRect(path,0.f,0.f,1.f,1.f);
 807                         //Log::getInstance()->log("OSD", Log::DEBUG, "Create APD Glyph %d %x",segments.size(),vgGetError());
 808                 }
 809                 VGfloat ori[]={0.f,0.f};
 810                 VGfloat esp[]={ft_face->glyph->advance.x/256.f*aspect_correction,ft_face->glyph->advance.y/256.f};
 811                 font_exp_x[glyph]=ft_face->glyph->advance.x/256.f*aspect_correction; //recalculate
 812
 813                 vgSetGlyphToPath(vgfont,glyph,path,VG_FALSE,ori,esp);
 814                 //Log::getInstance()->log("OSD", Log::DEBUG, "Create Glyph %d %d %x",path,glyph,vgGetError());
 815                 if (path!=VG_INVALID_HANDLE) {
 816                         vgDestroyPath(path);
 817                 }
 818                 cur_char = FT_Get_Next_Char(ft_face,cur_char,&glyph);
 819         }
 820         return 1;
 821 }
 822
 823
 824 void OsdOpenVG::drawSetTrans(SurfaceCommands & sc)
 825 {
 826         vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
 827         vgLoadIdentity();
 828         vgScale(((float)BACKBUFFER_WIDTH)/720.f, -((float)BACKBUFFER_HEIGHT)/576.f);
 829         vgTranslate(0.f+sc.x,-576.f+sc.y);
 830
 831         vgSeti(VG_MATRIX_MODE, VG_MATRIX_GLYPH_USER_TO_SURFACE);
 832         vgLoadIdentity();
 833     vgScale(((float)BACKBUFFER_WIDTH)/720.f, -((float)BACKBUFFER_HEIGHT)/576.f);
 834         vgTranslate(0.f+sc.x,-576.f+sc.y);
 835
 836         vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);
 837         vgLoadIdentity();
 838         vgScale(((float)BACKBUFFER_WIDTH)/720.f, -((float)BACKBUFFER_HEIGHT)/576.f);
 839         vgTranslate(0.f+sc.x,-576.f+sc.y);
 840     clip_shift_x=sc.x;
 841     clip_shift_y=sc.y;
 842
 843
 844
 845         //vgTranslate(0.f+sc.x,576.f-sc.y);
 846         //Log::getInstance()->log("OSD", Log::DEBUG, "Draw Translate %g %g",sc.x,sc.y);
 847
 848 }
 849 void OsdOpenVG::executeDrawCommand(SVGCommand & command)
 850 {
 851
 852         VGfloat  save_matrix[9];
 853         VGfloat  save_matrix2[9];
 854         switch (command.instr) {
 855         case DrawPath: {
 856         vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
 857         //      VGuint rgba;
 858         //      rgba = vgGetColor((VGPaint) command.reference);
 859                 //Log::getInstance()->log("OSD", Log::DEBUG, "Draw Path %d %x %g %g %g %g",command.reference,command.target.path_index,command.x,command.y,command.w,command.h);
 860                 //vgSeti(VG_FILL_RULE,);
 861
 862                 vgGetMatrix(save_matrix);
 863                 vgSetPaint((VGPaint) command.reference,VG_FILL_PATH);
 864                 vgSetPaint((VGPaint) command.reference,VG_STROKE_PATH);
 865                 vgTranslate(command.x,command.y);
 866                 vgScale(command.w,command.h);
 867                 vgDrawPath(std_paths[command.target.path_index],VG_FILL_PATH);
 868                 vgLoadMatrix(save_matrix);
 869         } break;
 870         case DrawImage: {
 871             vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);
 872                 vgGetMatrix(save_matrix);
 873                 VGfloat imagewidth=vgGetParameteri((VGImage) command.target.image, VG_IMAGE_WIDTH);
 874                 VGfloat imageheight=vgGetParameteri((VGImage) command.target.image, VG_IMAGE_HEIGHT);
 875
 876
 877                 //vgScale(command.w,command.h);
 878
 879                 if (command.reference) { //special behaviout for bw images they act as a mask on the current paint
 880                         vgTranslate(command.x,command.y);
 881                         vgSetPaint((VGPaint) command.reference,VG_FILL_PATH);
 882                         vgSetPaint((VGPaint) command.reference,VG_STROKE_PATH);
 883                         vgSeti(VG_IMAGE_MODE,VG_DRAW_IMAGE_STENCIL);
 884                         vgSeti(VG_BLEND_MODE, VG_BLEND_SRC_OVER);
 885                         vgScale(aspect_correction,1.f);
 886                         vgSeti(VG_MATRIX_MODE, VG_MATRIX_FILL_PAINT_TO_USER);
 887                     vgGetMatrix(save_matrix2);
 888                     vgScale(imagewidth,imageheight);
 889                 } else {
 890
 891                         //vgScale(720.f/((float)BACKBUFFER_WIDTH), 576.f/((float)BACKBUFFER_HEIGHT));
 892                         float scalex=command.w/imagewidth;
 893                         float scaley=command.h/imageheight;
 894                         if (scalex==0.f && scaley==0.f) {
 895                                 scalex=aspect_correction;
 896                                 scaley=1.f;
 897                         } else if (scalex==0.f) {
 898                                 scalex=scaley*aspect_correction;
 899                         } else if (scaley==0.f) {
 900                                 scaley=scalex/aspect_correction;
 901                         }
 902                         float tx=command.x;
 903                         float ty=command.y;
 904
 905                         if (command.corner ==  BottomRight || command.corner ==  BottomLeft || command.corner == BottomMiddle)
 906                         {
 907                                 ty-=imageheight * scaley;
 908                         }
 909
 910                         if (command.corner ==  BottomRight || command.corner ==  TopRight)
 911                         {
 912                                 tx-=imagewidth * scalex;
 913                         }
 914
 915                         if (command.corner ==  BottomMiddle || command.corner ==  TopMiddle)
 916                         {
 917                                 tx-=imagewidth * scalex *0.5f;
 918                         }
 919
 920                         vgTranslate(tx,ty);
 921                         //vgScale(command.w/imagewidth,command.h/imageheight);
 922                         vgScale(scalex,scaley);
 923                         vgSeti(VG_BLEND_MODE, VG_BLEND_SRC_OVER);
 924                         vgSeti(VG_IMAGE_MODE,VG_DRAW_IMAGE_NORMAL);
 925                         //Log::getInstance()->log("OSD", Log::DEBUG, "TVMedia Draw Image Scale  %g %g %g %g %g %g",command.w,imagewidth,command.h,imageheight,scalex,scaley);
 926                 }
 927
 928
 929                 //vgLoadIdentity();
 930                 //vgTranslate(200.f,500.f);
 931                 //vgScale(100.f,100.f);
 932
 933                 vgDrawImage((VGImage) command.target.image);
 934                 //Log::getInstance()->log("OSD", Log::DEBUG, "Draw Image %d %x %g %g %g %g %x",command.reference,command.target.image,command.x,command.y,command.w,command.h,
 935                 //              vgGetError());
 936                 if (command.reference) {
 937                         vgSeti(VG_IMAGE_MODE,VG_DRAW_IMAGE_NORMAL);
 938                         vgSeti(VG_MATRIX_MODE, VG_MATRIX_FILL_PAINT_TO_USER);
 939                         vgLoadMatrix(save_matrix2);
 940                 }
 941                 vgSeti(VG_BLEND_MODE, VG_BLEND_SRC);
 942
 943                 vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);
 944                 vgLoadMatrix(save_matrix);
 945         } break;
 946         case DrawGlyph: {
 947                 vgSeti(VG_MATRIX_MODE, VG_MATRIX_GLYPH_USER_TO_SURFACE);
 948                 vgGetMatrix(save_matrix);
 949                 vgSetPaint((VGPaint) command.reference,VG_FILL_PATH);
 950                 vgSetPaint((VGPaint) command.reference,VG_STROKE_PATH);
 951                 vgTranslate(command.x,command.y);
 952                 vgSeti(VG_MATRIX_MODE, VG_MATRIX_FILL_PAINT_TO_USER);
 953                 vgGetMatrix(save_matrix2);
 954                 unsigned int glyph_index=FT_Get_Char_Index(ft_face,command.target.textchar);
 955             vgScale(font_exp_x[glyph_index],font_height);
 956
 957
 958                 VGfloat gori[]={0.,0.};
 959                 vgSetfv(VG_GLYPH_ORIGIN,2,gori);
 960
 961
 962                 vgDrawGlyph(vgfont,glyph_index,VG_FILL_PATH,VG_FALSE);
 963                 //vgDrawPath(std_paths[Rectangle],VG_FILL_PATH);
 964         /*      Log::getInstance()->log("OSD", Log::DEBUG, "Draw Glyph %d %c %d %g %g %x",command.reference,command.target.textchar,glyph_index,command.x,command.y,
 965                                                 vgGetError());*/
 966                 vgSeti(VG_MATRIX_MODE, VG_MATRIX_GLYPH_USER_TO_SURFACE);
 967                 vgLoadMatrix(save_matrix);
 968                 vgSeti(VG_MATRIX_MODE, VG_MATRIX_FILL_PAINT_TO_USER);
 969                 vgLoadMatrix(save_matrix2);
 970
 971                 vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
 972         } break;
 973         case DrawTTchar:{
 974                 cTeletextChar tchar;
 975                 tchar.setInternal(command.target.ttchar);
 976                 vgSeti(VG_MATRIX_MODE, VG_MATRIX_GLYPH_USER_TO_SURFACE);
 977                 vgGetMatrix(save_matrix);
 978                 enumTeletextColor ttforegcolour=tchar.GetFGColor();
 979                 enumTeletextColor ttbackgcolour=tchar.GetBGColor();
 980             if (tchar.GetBoxedOut()) {
 981                 ttforegcolour=ttcTransparent;
 982                 ttbackgcolour=ttcTransparent;
 983             }
 984             vgSeti(VG_IMAGE_MODE,VG_DRAW_IMAGE_STENCIL);
 985             vgSeti(VG_BLEND_MODE, VG_BLEND_SRC_OVER);
 986
 987
 988                 vgTranslate(command.x+command.w*11.85f*1.4f,command.y+command.h*19.75f);
 989                 VGfloat gori[]={0.,0.};
 990                 vgSetfv(VG_GLYPH_ORIGIN,2,gori);
 991
 992                 vgScale(-1.4f,2.f);
 993                 unsigned int color=Surface::enumTeletextColorToCoulour(ttbackgcolour).rgba();
 994                 color=color<<8 | (color &0xff000000)>>24;
 995                 vgSetColor(vgttpaint,color);
 996                 vgSetPaint((VGPaint) vgttpaint,VG_FILL_PATH);
 997                 vgSetPaint((VGPaint) vgttpaint,VG_STROKE_PATH);
 998                 cTeletextChar filled;
 999                 filled.setInternal(0x187f);
1000                 unsigned int glyph_index=loadTTchar(filled);
1001                 vgDrawGlyph(vgttfont,glyph_index,VG_FILL_PATH,VG_FALSE);
1002
1003                 color=Surface::enumTeletextColorToCoulour(ttforegcolour).rgba();
1004                 color=color<<8 | (color &0xff000000)>>24;
1005                 vgSetColor(vgttpaint,color);
1006                 vgSetPaint((VGPaint) vgttpaint,VG_FILL_PATH);
1007                 vgSetPaint((VGPaint) vgttpaint,VG_STROKE_PATH);
1008                 glyph_index=loadTTchar(tchar);
1009                 vgDrawGlyph(vgttfont,glyph_index,VG_FILL_PATH,VG_FALSE);
1010
1011                 /*      Log::getInstance()->log("OSD", Log::DEBUG, "Draw TTchar %x %x %x %x",glyph_index,ttforegcolour,Surface::enumTeletextColorToCoulour(ttforegcolour).rgba(),
1012                                         vgGetColor(vgttpaint));*/
1013
1014
1015                 vgLoadMatrix(save_matrix);
1016                 vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
1017                 vgSeti(VG_IMAGE_MODE,VG_DRAW_IMAGE_NORMAL);
1018                 vgSeti(VG_BLEND_MODE, VG_BLEND_SRC);
1019
1020         }break;
1021         case DrawClipping: {
1022                 VGint coords[4]={0,0,0,0};
1023                 coords[0]= ((command.x+clip_shift_x)*((float)BACKBUFFER_WIDTH)/720.f);
1024                 coords[1]= ((576.f-command.y-clip_shift_y-command.h)*((float)BACKBUFFER_HEIGHT)/576.f);
1025                 coords[2]= ((command.w-1.f)*((float)BACKBUFFER_WIDTH)/720.f);
1026                 coords[3]= ((command.h-1.f)*((float)BACKBUFFER_HEIGHT)/576.f);
1027                 vgSetiv(VG_SCISSOR_RECTS, 4,coords);
1028                 if (command.w==0.f && command.h==0.f)
1029                         vgSeti(VG_SCISSORING,VG_FALSE);
1030                 else vgSeti(VG_SCISSORING,VG_TRUE);
1031         } break;
1032         }
1033 }
1034
1035 unsigned int OsdOpenVG::handleTask(OpenVGCommand& command)
1036 {
1037         switch (command.task){
1038         case OVGreplacefont: {
1039                  vgDestroyFont(vgfont);
1040                  loadFont(true);
1041                  return 0;
1042         } break;
1043
1044         case OVGdestroyImageRef: {
1045                 //Log::getInstance()->log("OSD", Log::DEBUG, "TVMedia Draw Image Destroy %d ",command.param1);
1046                 vgDestroyImage((VGImage)command.param1);
1047                 return 0;
1048         } break;
1049         case OVGdestroyPaint: {
1050                 //Log::getInstance()->log("OSD", Log::DEBUG, "Draw Paint Destroy %d ",command.param1);
1051                 vgDestroyPaint((VGPaint)command.param1);
1052                 return 0;
1053         } break;
1054         case OVGcreateImagePalette: {
1055                 VGImage input=vgCreateImage(VG_A_8,command.param1, command.param2,
1056                                 VG_IMAGE_QUALITY_NONANTIALIASED|
1057                                 VG_IMAGE_QUALITY_FASTER|VG_IMAGE_QUALITY_BETTER);
1058                 //Log::getInstance()->log("OSD", Log::DEBUG, "Draw create palette  %d %d %x %d",command.param1,command.param2,vgGetError(),input);
1059                 vgImageSubData(input,command.data,command.param1,
1060                                                         VG_A_8,0,0,command.param1, command.param2); // upload palettized image data
1061                 VGImage handle=vgCreateImage(VG_sRGBA_8888,command.param1, command.param2,
1062                                                 VG_IMAGE_QUALITY_NONANTIALIASED|
1063                                                 VG_IMAGE_QUALITY_FASTER|VG_IMAGE_QUALITY_BETTER);
1064                 VGuint *palette=(VGuint*)malloc(256*sizeof(VGuint));
1065                 VGuint *in_palette=(VGuint*)command.data2;
1066                 for (int i=0;i<256;i++) {
1067                         VGuint color=in_palette[i];
1068                         palette[i]=color<<8 | (color &0xff000000)>>24;
1069                 }
1070
1071                 vgLookupSingle(handle,input,palette,VG_ALPHA,VG_FALSE,VG_FALSE);
1072                 free(palette);
1073                 vgDestroyImage(input);
1074
1075                 return handle;
1076         } break;
1077         case OVGcreateMonoBitmap: {
1078                 VGImage handle=vgCreateImage(VG_A_1,command.param1, command.param2,
1079                                         VG_IMAGE_QUALITY_FASTER);
1080                 //Log::getInstance()->log("OSD", Log::DEBUG, "Draw create mono  %d %d %x %d",command.param1,command.param2,vgGetError(),handle);
1081                 unsigned int buffer_len=(command.param1*command.param2)>>3;
1082                 unsigned char * buffer=(unsigned char*)malloc(buffer_len);
1083                 unsigned char * r_buffer1=buffer;
1084                 const unsigned char * r_buffer2=(const unsigned char *)command.data;
1085                 unsigned char *buffer_end=buffer+buffer_len;
1086                 while (r_buffer1!=buffer_end) {
1087                         unsigned char byte=*r_buffer2;
1088                         *r_buffer1=((byte * 0x0802LU & 0x22110LU) | (byte * 0x8020LU & 0x88440LU)) * 0x10101LU >> 16;
1089                         r_buffer1++;r_buffer2++;
1090                 }
1091
1092
1093                 vgImageSubData(handle,buffer,command.param1>>3,
1094                                         VG_A_1,0,0,command.param1, command.param2);
1095                 free(buffer);
1096         //      Log::getInstance()->log("OSD", Log::DEBUG, "Draw create mono2  %d %d %x %d",command.param1,command.param2,vgGetError(),handle);
1097                 return handle;
1098         } break;
1099         /*case OVGcreateImageFile: {
1100                 VGImage handle;
1101                 try{
1102                         Image *imagefile=(Image*)command.data;
1103                         Blob imageblob;
1104                         imagefile->write(&imageblob,"RGBA");
1105
1106
1107                         handle=vgCreateImage(VG_sXBGR_8888,imagefile->columns(),imagefile->rows(),
1108                                         VG_IMAGE_QUALITY_BETTER);
1109                         //Log::getInstance()->log("OSD", Log::DEBUG, "Draw create image details  %d %d %x mark1",imagefile->columns(),imagefile->rows(),(unsigned int*)imageblob.data());
1110                         vgImageSubData(handle,imageblob.data(),imagefile->columns()*4,
1111                                         VG_sXBGR_8888,0,0,imagefile->columns(),imagefile->rows());
1112                         //Log::getInstance()->log("OSD", Log::DEBUG, "Draw create image details  %d %d %x mark2",imagefile->columns(),imagefile->rows(),(unsigned int*)imageblob.data());
1113                         delete imagefile;
1114                 }catch( Exception &error_ )
1115                 {
1116                         Log::getInstance()->log("OSD", Log::DEBUG, "Libmagick hT: %s",error_.what());
1117
1118                         return 0;
1119                 }
1120
1121                 //Log::getInstance()->log("OSD", Log::DEBUG, "Draw create file  %d %d %x %d",command.param1,command.param2,vgGetError(),handle);
1122                 return handle;
1123         } break;*/
1124         case OVGcreateImageMemory: {
1125                 PictureInfo *info = (PictureInfo*) command.data;
1126                 VGImage handle;
1127                 //Log::getInstance()->log("OSD", Log::DEBUG, "TVMedia OVGcreateImageMemory");
1128                 handle=vgCreateImage(VG_sABGR_8888,info->width,info->height,VG_IMAGE_QUALITY_BETTER);
1129                 vgImageSubData(handle,info->image,info->width*4,
1130                                                         VG_sABGR_8888,0,0,info->width,info->height);
1131                 info->decoder->freeReference(info->reference);
1132
1133                 bool static_image=true;
1134                 if (info->lindex & 0xffffffff) static_image=false;
1135
1136                 Message* m = new  Message();
1137                 // We have a pictures! send a message to ourself, to switch to gui thread
1138                 m->from=this;
1139                 m->to=Command::getInstance();
1140                 m->parameter = handle;
1141                 if (!static_image) {
1142                         m->message=Message::NEW_PICTURE;
1143                         m->tag = info->lindex;
1144                 } else {
1145                         m->message=Message::NEW_PICTURE_STATIC;
1146                         m->tag = info->lindex>> 32LL;
1147                 }
1148                 m->tag = info->lindex;
1149                 Command::getInstance()->postMessageFromOuterSpace(m); // inform command about new picture
1150
1151                 delete info;
1152
1153         } break;
1154         case OVGcreateEGLImage: {
1155                 PictureInfo *info = (PictureInfo*) command.data;
1156                 VGImage handle;
1157                 //Log::getInstance()->log("OSD", Log::DEBUG, "TVMedia OVGcreateImageMemory %d %d",info->width,info->height);
1158                 handle=vgCreateImage(VG_sABGR_8888,info->width,info->height,VG_IMAGE_QUALITY_BETTER);
1159
1160                 info->handle = handle;
1161                 info->reference =  eglCreateImageKHR(egl_display, egl_context, EGL_VG_PARENT_IMAGE_KHR, (EGLClientBuffer)handle, NULL);
1162                 if (info->reference) return true;
1163                 else return false;
1164
1165         } break;
1166
1167         case OVGreadyEGLImage: {
1168                 PictureInfo *info = (PictureInfo*) command.data;
1169                 eglDestroyImageKHR(egl_display,info->reference);
1170                 bool static_image=true;
1171                 if (info->lindex & 0xffffffff) static_image=false;
1172
1173                 Message* m = new  Message();
1174                 m->from=this;
1175                 m->to=Command::getInstance();
1176                 m->parameter = info->handle;
1177                 if (!static_image) {
1178                         m->message=Message::NEW_PICTURE;
1179                         m->tag = info->lindex;
1180                 } else {
1181                         m->message=Message::NEW_PICTURE_STATIC;
1182                         m->tag = info->lindex>> 32LL;
1183                 }
1184                 Command::getInstance()->postMessageFromOuterSpace(m); // inform command about new picture
1185
1186                 delete info;
1187         } break;
1188
1189
1190
1191         case OVGcreateColorRef :{
1192                 VGPaint handle;
1193                 handle=vgCreatePaint();
1194                 DrawStyle *style=(DrawStyle*)command.data;
1195                 switch (style->ft) {
1196                 case DrawStyle::Color: {
1197                         vgSetParameteri(handle, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
1198                         vgSetColor(handle,command.param1);
1199                         VGuint rgba;
1200                         rgba = vgGetColor((VGPaint)handle);
1201                         Log::getInstance()->log("OSD", Log::DEBUG, "Draw Paint %d %x %x",handle,command.param1,rgba);
1202                 } break;
1203                 case DrawStyle::GradientLinear: {
1204                         vgSetParameteri(handle, VG_PAINT_TYPE, VG_PAINT_TYPE_LINEAR_GRADIENT);
1205                         VGfloat params[]={style->x1,style->y1,style->x2,style->y2,style->r};
1206                         Log::getInstance()->log("OSD", Log::DEBUG, "Draw Gradient %d %g %g %g %g",handle,params[0],params[1],params[2],params[3]);
1207                         vgSetParameterfv(handle,VG_PAINT_LINEAR_GRADIENT,4,params);
1208
1209
1210
1211                 } break;
1212                 case DrawStyle::GradientRadial: {
1213                         vgSetParameteri(handle, VG_PAINT_TYPE, VG_PAINT_TYPE_RADIAL_GRADIENT);
1214                         VGfloat params[]={style->x1,style->y1,style->x2,style->y2,style->r};
1215                         vgSetParameterfv(handle,VG_PAINT_RADIAL_GRADIENT,5,params);
1216
1217
1218
1219                 } break;
1220                 };
1221                 if (style->ft==DrawStyle::GradientLinear ||style->ft==DrawStyle::GradientRadial) {
1222                         VGfloat colorramp[5*5];
1223                         colorramp[0+0*5]=0.f;
1224                         colorramp[1+0*5]=((float)style->red)/255.f;
1225                         colorramp[2+0*5]=((float)style->green)/255.f;
1226                         colorramp[3+0*5]=((float)style->blue)/255.f;
1227                         colorramp[4+0*5]=((float)style->alpha)/255.f;
1228                         for (int i=0;i<(style->num_colors-1);i++) {
1229                                 colorramp[0+(i+1)*5]=style->grad_pos[i];
1230                                 colorramp[1+(i+1)*5]=((float)style->grad_col[i].red)/255.f;
1231                                 colorramp[2+(i+1)*5]=((float)style->grad_col[i].green)/255.f;
1232                                 colorramp[3+(i+1)*5]=((float)style->grad_col[i].blue)/255.f;
1233                                 colorramp[4+(i+1)*5]=((float)style->grad_col[i].alpha)/255.f;
1234                         }
1235                         colorramp[0+(style->num_colors)*5]=1.f;
1236                         colorramp[1+(style->num_colors)*5]=((float)style->grad_col[style->num_colors-1].red)/255.f;
1237                         colorramp[2+(style->num_colors)*5]=((float)style->grad_col[style->num_colors-1].green)/255.f;
1238                         colorramp[3+(style->num_colors)*5]=((float)style->grad_col[style->num_colors-1].blue)/255.f;
1239                         colorramp[4+(style->num_colors)*5]=((float)style->grad_col[style->num_colors-1].alpha)/255.f;
1240                         vgSetParameteri(handle, VG_PAINT_COLOR_RAMP_SPREAD_MODE,VG_COLOR_RAMP_SPREAD_REFLECT);
1241                         vgSetParameteri(handle, VG_PAINT_COLOR_RAMP_PREMULTIPLIED,VG_FALSE);
1242                         vgSetParameterfv(handle,VG_PAINT_COLOR_RAMP_STOPS,5+(style->num_colors)*5,colorramp);
1243                 }
1244
1245                 return handle;
1246         } break;
1247         case OVGimageUploadLine: {
1248                 vgImageSubData((VGImage)command.param1,command.data,0,VG_sARGB_8888,0,command.param2,command.param3,1);
1249                 return 0;
1250         } break;
1251
1252         }
1253 }
1254
1255 bool OsdOpenVG::processTasks()
1256 {
1257         bool worked=false;
1258         taskmutex.Lock();
1259         vgmutex.Lock();
1260         while (vgcommands.size()>0)
1261         {
1262                 OpenVGCommand comm=vgcommands.front();
1263                 vgcommands.pop_front();
1264                 taskmutex.Unlock();
1265
1266                 OpenVGResponse resp;
1267                 resp.result=handleTask(comm);
1268                 resp.id=comm.id;
1269                 taskmutex.Lock();
1270                 if (comm.id) {
1271                         vgresponses.push_back(resp);
1272                 }
1273                 taskmutex.Unlock();
1274                 vgmutex.Unlock();
1275                 //threadCheckExit();
1276                 vgtaskSignal.signal();
1277                 taskmutex.Lock();
1278                 vgmutex.Lock();
1279                 worked=true;
1280         }
1281         taskmutex.Unlock();
1282         vgmutex.Unlock();
1283
1284         return worked;
1285 }
1286
1287 bool OsdOpenVG::haveOpenVGResponse(unsigned int id,unsigned int * resp)
1288 {
1289         taskmutex.Lock();
1290         if (vgresponses.size()>0)
1291         {
1292                 deque<OpenVGResponse>::iterator itty=vgresponses.begin();
1293                 while (itty!=vgresponses.end())
1294                 {
1295                         if ((*itty).id==id) {
1296                                 *resp=(*itty).result;
1297                                 taskmutex.Unlock();
1298                                 return true;
1299                         }
1300                         itty++;
1301                 }
1302         }
1303         taskmutex.Unlock();
1304         return false;
1305 }
1306
1307
1308 unsigned int  OsdOpenVG::putOpenVGCommand(OpenVGCommand& comm,bool wait)
1309 {
1310         taskmutex.Lock();
1311         if (wait){
1312                 comm.id=wait_id;
1313                 wait_id++;
1314         } else {
1315                 comm.id=0; // we are not waiting
1316         }
1317         vgcommands.push_back(comm);
1318         taskmutex.Unlock();
1319         threadSignal();
1320         while (wait) {
1321                 unsigned int resp;
1322                 if (!haveOpenVGResponse(comm.id,&resp)) {
1323                         struct timespec target_time;
1324                         clock_gettime(CLOCK_REALTIME,&target_time);
1325                         target_time.tv_nsec+=1000000LL*100;
1326                         if (target_time.tv_nsec>999999999) {
1327                                         target_time.tv_nsec-=1000000000L;
1328                                         target_time.tv_sec+=1;
1329                         }
1330                         vgtaskSignal.waitForSignalTimed(&target_time);
1331                 } else {
1332                         return resp;
1333                 }
1334         }
1335         return 0;
1336 }
1337
1338 void OsdOpenVG::imageUploadLine(ImageIndex index,unsigned int j,unsigned int width,void *data)
1339 {
1340         vgImageSubData((VGImage)index,data,0,VG_sARGB_8888,0,j,width,1);
1341
1342         struct OpenVGCommand comm;
1343         comm.task=OVGimageUploadLine;
1344         comm.param1=index;
1345         comm.param2=j;
1346         comm.param3=width;
1347         comm.data=data;
1348         putOpenVGCommand(comm,true);
1349 }
1350
1351 void OsdOpenVG::destroyImageRef(ImageIndex index)
1352 {
1353         struct OpenVGCommand comm;
1354         comm.task=OVGdestroyImageRef;
1355         comm.param1=index;
1356         putOpenVGCommand(comm,false);
1357 }
1358 /*
1359 ImageIndex OsdOpenVG::createJpeg(const char* fileName, int *width,int *height)
1360 {
1361         Image* magicimage=NULL;
1362         struct OpenVGCommand comm;
1363         comm.task=OVGcreateImageFile;
1364
1365         try{
1366                 // Now figure out, if it is a special case
1367                 if (strcmp(fileName,"/vdr.jpg")==0) {
1368                         magicimage=new Image(Blob(vdr_data,vdr_data_end-vdr_data));
1369                         *height=100; // this is faked so that the system does use the old coordinate system
1370                         *width=ceil(190.f*aspect_correction);
1371                         Log::getInstance()->log("OSD", Log::DEBUG, "LoadIm vdr.jpg");
1372                 } else if (strcmp(fileName,"/wallpaperPAL.jpg")==0) {
1373                         magicimage=new Image(Blob(wallpaper_data,wallpaper_data_end-wallpaper_data));
1374                         *width=720; // this is faked so that the system does use the old coordinate system
1375                         *height=576;
1376                         Log::getInstance()->log("OSD", Log::DEBUG, "LoadIm wallpaperPAL.jpg");
1377                 } else {
1378                         magicimage=new Image();
1379                         magicimage->read(fileName);
1380                         Log::getInstance()->log("OSD", Log::DEBUG, "LoadIm file: %s",fileName);
1381                         *width=ceil(magicimage->baseColumns()*aspect_correction); // this is faked so that the system does use the old coordinate system
1382                         *height=magicimage->baseRows();
1383                 }
1384
1385         }catch( Exception &error_ )
1386         {
1387                 Log::getInstance()->log("OSD", Log::DEBUG, "Libmagick: %s",error_.what());
1388
1389                 return 0;
1390         }
1391         comm.data=magicimage;
1392         return putOpenVGCommand(comm,true);
1393 }*/
1394
1395 bool OsdOpenVG::getStaticImageData(unsigned int static_id, UCHAR **userdata, ULONG *length)
1396 {
1397         switch (static_id) {
1398         case 1: {
1399                 *userdata = vdr_data;
1400                 *length = vdr_data_end-vdr_data;
1401                 return true;
1402         } break;
1403         case 2: {
1404                 *userdata = wallpaper_data;
1405                 *length = wallpaper_data_end-wallpaper_data;
1406                 return true;
1407         } break;
1408         default: {
1409                 *userdata = NULL;
1410                 *length = 0;
1411                 return false;
1412         } break;
1413         };
1414 }
1415
1416 void  OsdOpenVG::createPicture(struct PictureInfo& pict_inf)
1417 {
1418         struct OpenVGCommand comm;
1419         if (pict_inf.type == PictureInfo::RGBAMemBlock) {
1420                 comm.task = OVGcreateImageMemory;
1421                 comm.data =  new PictureInfo(pict_inf);
1422                 putOpenVGCommand(comm,false);
1423         } else if (pict_inf.type == PictureInfo::EGLImage) {
1424                 comm.task = OVGreadyEGLImage;
1425                 comm.data =  new PictureInfo(pict_inf);
1426                 putOpenVGCommand(comm,false);
1427         } else {
1428                 // unsupported
1429                 pict_inf.decoder->freeReference(pict_inf.reference);
1430
1431
1432         }
1433 }
1434
1435 bool OsdOpenVG::getEGLPicture(struct OsdVector::PictureInfo & info , EGLDisplay * display)
1436 {
1437         struct OpenVGCommand comm;
1438         info.type = PictureInfo::EGLImage;
1439         comm.task = OVGcreateEGLImage;
1440         comm.data = &info;
1441         *display = egl_display;
1442         return  putOpenVGCommand(comm,true);
1443 }
1444
1445
1446
1447 ImageIndex OsdOpenVG::createMonoBitmap(void *base,int width,int height)
1448 {
1449         struct OpenVGCommand comm;
1450         comm.task=OVGcreateMonoBitmap;
1451         comm.param1=width;
1452         comm.param2=height;
1453         comm.data=base;
1454         return putOpenVGCommand(comm,true);
1455 }
1456
1457 ImageIndex OsdOpenVG::createImagePalette(int width,int height,const unsigned char *image_data,const unsigned int*palette_data)
1458 {
1459     struct OpenVGCommand comm;
1460     comm.task=OVGcreateImagePalette;
1461     comm.param1=width;
1462     comm.param2=height;
1463     comm.data=image_data;
1464     comm.data2=palette_data;
1465     return putOpenVGCommand(comm,true);
1466 }
1467
1468 void OsdOpenVG::destroyStyleRef(unsigned int index)
1469 {
1470         struct OpenVGCommand comm;
1471         comm.task=OVGdestroyPaint;
1472         comm.param1=index;
1473         putOpenVGCommand(comm,false);
1474 }
1475
1476 unsigned int OsdOpenVG::createStyleRef(const DrawStyle &c)
1477 {
1478         unsigned int col=c.rgba();
1479         struct OpenVGCommand comm;
1480         comm.task=OVGcreateColorRef;
1481         comm.param1=col<<8 | (col &0xff000000)>>24;
1482         comm.data=&c;
1483         return putOpenVGCommand(comm,true);
1484 }
1485
1486 unsigned int OsdOpenVG::createColorRef(const Colour &c)
1487 {
1488         unsigned int col=c.rgba();
1489         struct OpenVGCommand comm;
1490         comm.task=OVGcreateColorRef;
1491         comm.param1=col<<8 | (col &0xff000000)>>24;
1492         comm.data=&c;
1493         return putOpenVGCommand(comm,true);
1494 }
1495
1496