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