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