src/modules/engines/gl_common/evas_gl_shader.c

   1 #include "evas_gl_private.h"
   2
   3 /////////////////////////////////////////////
   4 #if defined (GLES_VARIETY_S3C6410)
   5 const unsigned int rect_frag_bin[] =
   6 {
   7 # include "shader/rect_frag_bin_s3c6410.h"
   8 };
   9 #endif
  10
  11 const char rect_frag_glsl[] =
  12 #include "shader/rect_frag.h"
  13   ;
  14 Evas_GL_Program_Source shader_rect_frag_src =
  15 {
  16    rect_frag_glsl,
  17 #if defined (GLES_VARIETY_S3C6410)
  18      rect_frag_bin, sizeof(rect_frag_bin)
  19 #else
  20      NULL, 0
  21 #endif
  22 };
  23
  24 #if defined (GLES_VARIETY_S3C6410)
  25 const unsigned int rect_vert_bin[] =
  26 {
  27 # include "shader/rect_vert_bin_s3c6410.h"
  28 };
  29 #endif
  30 const char rect_vert_glsl[] =
  31 #include "shader/rect_vert.h"
  32   ;
  33 Evas_GL_Program_Source shader_rect_vert_src =
  34 {
  35    rect_vert_glsl,
  36 #if defined (GLES_VARIETY_S3C6410)
  37      rect_vert_bin, sizeof(rect_vert_bin)
  38 #else
  39      NULL, 0
  40 #endif
  41 };
  42
  43 /////////////////////////////////////////////
  44 #if defined (GLES_VARIETY_S3C6410)
  45 const unsigned int font_frag_bin[] =
  46 {
  47 # include "shader/font_frag_bin_s3c6410.h"
  48 };
  49 #endif
  50
  51 const char font_frag_glsl[] =
  52 #include "shader/font_frag.h"
  53   ;
  54 Evas_GL_Program_Source shader_font_frag_src =
  55 {
  56    font_frag_glsl,
  57 #if defined (GLES_VARIETY_S3C6410)
  58      font_frag_bin, sizeof(font_frag_bin)
  59 #else
  60      NULL, 0
  61 #endif
  62 };
  63
  64 #if defined (GLES_VARIETY_S3C6410)
  65 const unsigned int font_vert_bin[] =
  66 {
  67 # include "shader/font_vert_bin_s3c6410.h"
  68 };
  69 #endif
  70 const char font_vert_glsl[] =
  71 #include "shader/font_vert.h"
  72   ;
  73 Evas_GL_Program_Source shader_font_vert_src =
  74 {
  75    font_vert_glsl,
  76 #if defined (GLES_VARIETY_S3C6410)
  77      font_vert_bin, sizeof(font_vert_bin)
  78 #else
  79      NULL, 0
  80 #endif
  81 };
  82
  83 /////////////////////////////////////////////
  84 #if defined (GLES_VARIETY_S3C6410)
  85 const unsigned int yuv_frag_bin[] =
  86 {
  87 # include "shader/yuv_frag_bin_s3c6410.h"
  88 };
  89 #endif
  90
  91 const char yuv_frag_glsl[] =
  92 #include "shader/yuv_frag.h"
  93   ;
  94 Evas_GL_Program_Source shader_yuv_frag_src =
  95 {
  96    yuv_frag_glsl,
  97 #if defined (GLES_VARIETY_S3C6410)
  98      yuv_frag_bin, sizeof(yuv_frag_bin)
  99 #else
 100      NULL, 0
 101 #endif
 102 };
 103
 104 #if defined (GLES_VARIETY_S3C6410)
 105 const unsigned int yuv_vert_bin[] =
 106 {
 107 # include "shader/yuv_vert_bin_s3c6410.h"
 108 };
 109 #endif
 110 const char yuv_vert_glsl[] =
 111 #include "shader/yuv_vert.h"
 112   ;
 113 Evas_GL_Program_Source shader_yuv_vert_src =
 114 {
 115    yuv_vert_glsl,
 116 #if defined (GLES_VARIETY_S3C6410)
 117      yuv_vert_bin, sizeof(yuv_vert_bin)
 118 #else
 119      NULL, 0
 120 #endif
 121 };
 122
 123 /////////////////////////////////////////////
 124 #if defined (GLES_VARIETY_S3C6410)
 125 const unsigned int yuv_nomul_frag_bin[] =
 126 {
 127 # include "shader/yuv_nomul_frag_bin_s3c6410.h"
 128 };
 129 #endif
 130
 131 const char yuv_nomul_frag_glsl[] =
 132 #include "shader/yuv_nomul_frag.h"
 133   ;
 134 Evas_GL_Program_Source shader_yuv_nomul_frag_src =
 135 {
 136    yuv_nomul_frag_glsl,
 137 #if defined (GLES_VARIETY_S3C6410)
 138      yuv_nomul_frag_bin, sizeof(yuv_nomul_frag_bin)
 139 #else
 140      NULL, 0
 141 #endif
 142 };
 143
 144 #if defined (GLES_VARIETY_S3C6410)
 145 const unsigned int yuv_nomul_vert_bin[] =
 146 {
 147 # include "shader/yuv_nomul_vert_bin_s3c6410.h"
 148 };
 149 #endif
 150 const char yuv_nomul_vert_glsl[] =
 151 #include "shader/yuv_nomul_vert.h"
 152   ;
 153 Evas_GL_Program_Source shader_yuv_nomul_vert_src =
 154 {
 155    yuv_nomul_vert_glsl,
 156 #if defined (GLES_VARIETY_S3C6410)
 157      yuv_nomul_vert_bin, sizeof(yuv_nomul_vert_bin)
 158 #else
 159      NULL, 0
 160 #endif
 161 };
 162
 163 /////////////////////////////////////////////
 164 #if defined (GLES_VARIETY_S3C6410)
 165 const unsigned int tex_frag_bin[] =
 166 {
 167 # include "shader/tex_frag_bin_s3c6410.h"
 168 };
 169 #endif
 170
 171 const char tex_frag_glsl[] =
 172 #include "shader/tex_frag.h"
 173   ;
 174 Evas_GL_Program_Source shader_tex_frag_src =
 175 {
 176    tex_frag_glsl,
 177 #if defined (GLES_VARIETY_S3C6410)
 178      tex_frag_bin, sizeof(tex_frag_bin)
 179 #else
 180      NULL, 0
 181 #endif
 182 };
 183
 184 #if defined (GLES_VARIETY_S3C6410)
 185 const unsigned int tex_vert_bin[] =
 186 {
 187 # include "shader/tex_vert_bin_s3c6410.h"
 188 };
 189 #endif
 190 const char tex_vert_glsl[] =
 191 #include "shader/tex_vert.h"
 192   ;
 193 Evas_GL_Program_Source shader_tex_vert_src =
 194 {
 195    tex_vert_glsl,
 196 #if defined (GLES_VARIETY_S3C6410)
 197      tex_vert_bin, sizeof(tex_vert_bin)
 198 #else
 199      NULL, 0
 200 #endif
 201 };
 202
 203 /////////////////////////////////////////////
 204 #if defined (GLES_VARIETY_S3C6410)
 205 const unsigned int tex_nomul_frag_bin[] =
 206 {
 207 # include "shader/tex_nomul_frag_bin_s3c6410.h"
 208 };
 209 #endif
 210
 211 const char tex_nomul_frag_glsl[] =
 212 #include "shader/tex_nomul_frag.h"
 213   ;
 214 Evas_GL_Program_Source shader_tex_nomul_frag_src =
 215 {
 216    tex_nomul_frag_glsl,
 217 #if defined (GLES_VARIETY_S3C6410)
 218      tex_nomul_frag_bin, sizeof(tex_nomul_frag_bin)
 219 #else
 220      NULL, 0
 221 #endif
 222 };
 223
 224 #if defined (GLES_VARIETY_S3C6410)
 225 const unsigned int tex_nomul_vert_bin[] =
 226 {
 227 # include "shader/tex_nomul_vert_bin_s3c6410.h"
 228 };
 229 #endif
 230 const char tex_nomul_vert_glsl[] =
 231 #include "shader/tex_nomul_vert.h"
 232   ;
 233 Evas_GL_Program_Source shader_tex_nomul_vert_src =
 234 {
 235    tex_nomul_vert_glsl,
 236 #if defined (GLES_VARIETY_S3C6410)
 237      tex_nomul_vert_bin, sizeof(tex_nomul_vert_bin)
 238 #else
 239      NULL, 0
 240 #endif
 241 };
 242
 243 /////////////////////////////////////////////
 244 #if defined (GLES_VARIETY_S3C6410)
 245 const unsigned int img_frag_bin[] =
 246 {
 247 # include "shader/img_frag_bin_s3c6410.h"
 248 };
 249 #endif
 250
 251 const char img_frag_glsl[] =
 252 #include "shader/img_frag.h"
 253   ;
 254 Evas_GL_Program_Source shader_img_frag_src =
 255 {
 256    img_frag_glsl,
 257 #if defined (GLES_VARIETY_S3C6410)
 258      img_frag_bin, sizeof(img_frag_bin)
 259 #else
 260      NULL, 0
 261 #endif
 262 };
 263
 264 #if defined (GLES_VARIETY_S3C6410)
 265 const unsigned int img_vert_bin[] =
 266 {
 267 # include "shader/img_vert_bin_s3c6410.h"
 268 };
 269 #endif
 270 const char img_vert_glsl[] =
 271 #include "shader/img_vert.h"
 272   ;
 273 Evas_GL_Program_Source shader_img_vert_src =
 274 {
 275    img_vert_glsl,
 276 #if defined (GLES_VARIETY_S3C6410)
 277      img_vert_bin, sizeof(img_vert_bin)
 278 #else
 279      NULL, 0
 280 #endif
 281 };
 282
 283 /////////////////////////////////////////////
 284 #if defined (GLES_VARIETY_S3C6410)
 285 const unsigned int img_nomul_frag_bin[] =
 286 {
 287 # include "shader/img_nomul_frag_bin_s3c6410.h"
 288 };
 289 #endif
 290
 291 const char img_nomul_frag_glsl[] =
 292 #include "shader/img_nomul_frag.h"
 293   ;
 294 Evas_GL_Program_Source shader_img_nomul_frag_src =
 295 {
 296    img_nomul_frag_glsl,
 297 #if defined (GLES_VARIETY_S3C6410)
 298      img_nomul_frag_bin, sizeof(img_nomul_frag_bin)
 299 #else
 300      NULL, 0
 301 #endif
 302 };
 303
 304 #if defined (GLES_VARIETY_S3C6410)
 305 const unsigned int img_nomul_vert_bin[] =
 306 {
 307 # include "shader/img_nomul_vert_bin_s3c6410.h"
 308 };
 309 #endif
 310 const char img_nomul_vert_glsl[] =
 311 #include "shader/img_nomul_vert.h"
 312   ;
 313 Evas_GL_Program_Source shader_img_nomul_vert_src =
 314 {
 315    img_nomul_vert_glsl,
 316 #if defined (GLES_VARIETY_S3C6410)
 317      img_nomul_vert_bin, sizeof(img_nomul_vert_bin)
 318 #else
 319      NULL, 0
 320 #endif
 321 };
 322
 323 /////////////////////////////////////////////
 324 #if defined (GLES_VARIETY_S3C6410)
 325 const unsigned int img_bgra_frag_bin[] =
 326 {
 327 # include "shader/img_bgra_frag_bin_s3c6410.h"
 328 };
 329 #endif
 330
 331 const char img_bgra_frag_glsl[] =
 332 #include "shader/img_bgra_frag.h"
 333   ;
 334 Evas_GL_Program_Source shader_img_bgra_frag_src =
 335 {
 336    img_bgra_frag_glsl,
 337 #if defined (GLES_VARIETY_S3C6410)
 338      img_bgra_frag_bin, sizeof(img_bgra_frag_bin)
 339 #else
 340      NULL, 0
 341 #endif
 342 };
 343
 344 #if defined (GLES_VARIETY_S3C6410)
 345 const unsigned int img_bgra_vert_bin[] =
 346 {
 347 # include "shader/img_bgra_vert_bin_s3c6410.h"
 348 };
 349 #endif
 350 const char img_bgra_vert_glsl[] =
 351 #include "shader/img_bgra_vert.h"
 352   ;
 353 Evas_GL_Program_Source shader_img_bgra_vert_src =
 354 {
 355    img_bgra_vert_glsl,
 356 #if defined (GLES_VARIETY_S3C6410)
 357      img_bgra_vert_bin, sizeof(img_bgra_vert_bin)
 358 #else
 359      NULL, 0
 360 #endif
 361 };
 362
 363
 364 /////////////////////////////////////////////
 365 #if defined (GLES_VARIETY_S3C6410)
 366 const unsigned int img_mask_frag_bin[] =
 367 {
 368 # include "shader/img_mask_frag_bin_s3c6410.h"
 369 };
 370 #endif
 371
 372 const char img_mask_frag_glsl[] =
 373 #include "shader/img_mask_frag.h"
 374   ;
 375 Evas_GL_Program_Source shader_img_mask_frag_src =
 376 {
 377    img_mask_frag_glsl,
 378 #if defined (GLES_VARIETY_S3C6410)
 379      img_mask_frag_bin, sizeof(img_mask_frag_bin)
 380 #else
 381      NULL, 0
 382 #endif
 383 };
 384
 385 #if defined (GLES_VARIETY_S3C6410)
 386 const unsigned int img_mask_vert_bin[] =
 387 {
 388 # include "shader/img_mask_vert_bin_s3c6410.h"
 389 };
 390 #endif
 391 const char img_mask_vert_glsl[] =
 392 #include "shader/img_mask_vert.h"
 393   ;
 394 Evas_GL_Program_Source shader_img_mask_vert_src =
 395 {
 396    img_mask_vert_glsl,
 397 #if defined (GLES_VARIETY_S3C6410)
 398      img_mask_vert_bin, sizeof(img_mask_vert_bin)
 399 #else
 400      NULL, 0
 401 #endif
 402 };
 403
 404
 405 /////////////////////////////////////////////
 406 #if defined (GLES_VARIETY_S3C6410)
 407 const unsigned int img_bgra_nomul_frag_bin[] =
 408 {
 409 # include "shader/img_bgra_nomul_frag_bin_s3c6410.h"
 410 };
 411 #endif
 412
 413 const char img_bgra_nomul_frag_glsl[] =
 414 #include "shader/img_bgra_nomul_frag.h"
 415   ;
 416 Evas_GL_Program_Source shader_img_bgra_nomul_frag_src =
 417 {
 418    img_bgra_nomul_frag_glsl,
 419 #if defined (GLES_VARIETY_S3C6410)
 420      img_bgra_nomul_frag_bin, sizeof(img_bgra_nomul_frag_bin)
 421 #else
 422      NULL, 0
 423 #endif
 424 };
 425
 426 #if defined (GLES_VARIETY_S3C6410)
 427 const unsigned int img_bgra_nomul_vert_bin[] =
 428 {
 429 # include "shader/img_bgra_nomul_vert_bin_s3c6410.h"
 430 };
 431 #endif
 432 const char img_bgra_nomul_vert_glsl[] =
 433 #include "shader/img_bgra_nomul_vert.h"
 434   ;
 435 Evas_GL_Program_Source shader_img_bgra_nomul_vert_src =
 436 {
 437    img_bgra_nomul_vert_glsl,
 438 #if defined (GLES_VARIETY_S3C6410)
 439      img_bgra_nomul_vert_bin, sizeof(img_bgra_nomul_vert_bin)
 440 #else
 441      NULL, 0
 442 #endif
 443 };
 444
 445 /////////////////////////////////////////////
 446 const char filter_invert_frag_glsl[] =
 447 #include "shader/filter_invert.h"
 448   ;
 449 Evas_GL_Program_Source shader_filter_invert_frag_src =
 450 {
 451    filter_invert_frag_glsl,
 452    NULL, 0
 453 };
 454
 455 const char filter_invert_nomul_frag_glsl[] =
 456 #include "shader/filter_invert_nomul.h"
 457   ;
 458 Evas_GL_Program_Source shader_filter_invert_nomul_frag_src =
 459 {
 460    filter_invert_nomul_frag_glsl,
 461    NULL, 0
 462 };
 463
 464 const char filter_invert_bgra_frag_glsl[] =
 465 #include "shader/filter_invert_bgra.h"
 466   ;
 467 Evas_GL_Program_Source shader_filter_invert_bgra_frag_src =
 468 {
 469    filter_invert_bgra_frag_glsl,
 470    NULL, 0
 471 };
 472 const char filter_invert_bgra_nomul_frag_glsl[] =
 473 #include "shader/filter_invert_bgra_nomul.h"
 474   ;
 475 Evas_GL_Program_Source shader_filter_invert_bgra_nomul_frag_src =
 476 {
 477    filter_invert_bgra_nomul_frag_glsl,
 478    NULL, 0
 479 };
 480
 481 /////////////////////////////////////////////
 482 const char filter_greyscale_frag_glsl[] =
 483 #include "shader/filter_greyscale.h"
 484   ;
 485 Evas_GL_Program_Source shader_filter_greyscale_frag_src =
 486 {
 487    filter_greyscale_frag_glsl,
 488    NULL, 0
 489 };
 490
 491 const char filter_greyscale_nomul_frag_glsl[] =
 492 #include "shader/filter_greyscale_nomul.h"
 493   ;
 494 Evas_GL_Program_Source shader_filter_greyscale_nomul_frag_src =
 495 {
 496    filter_greyscale_nomul_frag_glsl,
 497    NULL, 0
 498 };
 499
 500 const char filter_greyscale_bgra_frag_glsl[] =
 501 #include "shader/filter_greyscale_bgra.h"
 502   ;
 503 Evas_GL_Program_Source shader_filter_greyscale_bgra_frag_src =
 504 {
 505    filter_greyscale_bgra_frag_glsl,
 506    NULL, 0
 507 };
 508 const char filter_greyscale_bgra_nomul_frag_glsl[] =
 509 #include "shader/filter_greyscale_bgra_nomul.h"
 510   ;
 511 Evas_GL_Program_Source shader_filter_greyscale_bgra_nomul_frag_src =
 512 {
 513    filter_greyscale_bgra_nomul_frag_glsl,
 514    NULL, 0
 515 };
 516
 517 /////////////////////////////////////////////
 518 const char filter_sepia_frag_glsl[] =
 519 #include "shader/filter_sepia.h"
 520   ;
 521 Evas_GL_Program_Source shader_filter_sepia_frag_src =
 522 {
 523    filter_sepia_frag_glsl,
 524    NULL, 0
 525 };
 526
 527 const char filter_sepia_nomul_frag_glsl[] =
 528 #include "shader/filter_sepia_nomul.h"
 529   ;
 530 Evas_GL_Program_Source shader_filter_sepia_nomul_frag_src =
 531 {
 532    filter_sepia_nomul_frag_glsl,
 533    NULL, 0
 534 };
 535
 536 const char filter_sepia_bgra_frag_glsl[] =
 537 #include "shader/filter_sepia_bgra.h"
 538   ;
 539 Evas_GL_Program_Source shader_filter_sepia_bgra_frag_src =
 540 {
 541    filter_sepia_bgra_frag_glsl,
 542    NULL, 0
 543 };
 544 const char filter_sepia_bgra_nomul_frag_glsl[] =
 545 #include "shader/filter_sepia_bgra_nomul.h"
 546   ;
 547 Evas_GL_Program_Source shader_filter_sepia_bgra_nomul_frag_src =
 548 {
 549    filter_sepia_bgra_nomul_frag_glsl,
 550    NULL, 0
 551 };
 552
 553 /////////////////////////////////////////////
 554 #if 0
 555         Blur is a work in progress currently.
 556         Mostly because GPUs are so hopeless.
 557 const char filter_blur_vert_glsl[] =
 558 #include "shader/filter_blur_vert.h"
 559   ;
 560
 561 Evas_GL_Program_Source shader_filter_blur_vert_src =
 562 {
 563    filter_blur_vert_glsl,
 564    NULL, 0
 565 };
 566
 567 const char filter_blur_frag_glsl[] =
 568 #include "shader/filter_blur.h"
 569   ;
 570 Evas_GL_Program_Source shader_filter_blur_frag_src =
 571 {
 572    filter_blur_frag_glsl,
 573    NULL, 0
 574 };
 575
 576 const char filter_blur_nomul_frag_glsl[] =
 577 #include "shader/filter_blur_nomul.h"
 578   ;
 579 Evas_GL_Program_Source shader_filter_blur_nomul_frag_src =
 580 {
 581    filter_blur_nomul_frag_glsl,
 582    NULL, 0
 583 };
 584
 585 const char filter_blur_bgra_frag_glsl[] =
 586 #include "shader/filter_blur_bgra.h"
 587   ;
 588 Evas_GL_Program_Source shader_filter_blur_bgra_frag_src =
 589 {
 590    filter_blur_bgra_frag_glsl,
 591    NULL, 0
 592 };
 593 const char filter_blur_bgra_nomul_frag_glsl[] =
 594 #include "shader/filter_blur_bgra_nomul.h"
 595   ;
 596 Evas_GL_Program_Source shader_filter_blur_bgra_nomul_frag_src =
 597 {
 598    filter_blur_bgra_nomul_frag_glsl,
 599    NULL, 0
 600 };
 601
 602 #endif
 603
 604
 605
 606 /////////////////////////////////////////////
 607 static void
 608 gl_compile_link_error(GLuint target, const char *action)
 609 {
 610    int loglen = 0, chars = 0;
 611    char *logtxt;
 612
 613    /* Shader info log */
 614    glGetShaderiv(target, GL_INFO_LOG_LENGTH, &loglen);
 615    if (loglen > 0)
 616      {
 617         logtxt = calloc(loglen, sizeof(char));
 618         if (logtxt)
 619           {
 620              glGetShaderInfoLog(target, loglen, &chars, logtxt);
 621              ERR("Failed to %s: %s", action, logtxt);
 622              free(logtxt);
 623           }
 624      }
 625
 626    /* Program info log */
 627    glGetProgramiv(target, GL_INFO_LOG_LENGTH, &loglen);
 628    if (loglen > 0)
 629      {
 630         logtxt = calloc(loglen, sizeof(char));
 631         if (logtxt)
 632           {
 633              glGetProgramInfoLog(target, loglen, &chars, logtxt);
 634              ERR("Failed to %s: %s", action, logtxt);
 635              free(logtxt);
 636           }
 637      }
 638 }
 639
 640 static mode_t default_mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
 641
 642 static Eina_Bool
 643 _evas_gl_shader_file_is_dir(const char *file)
 644 {
 645    struct stat st;
 646
 647    if (stat(file, &st) < 0) return EINA_FALSE;
 648    if (S_ISDIR(st.st_mode)) return EINA_TRUE;
 649    return EINA_FALSE;
 650 }
 651
 652 static Eina_Bool
 653 _evas_gl_shader_file_mkdir(const char *dir)
 654 {
 655    /* evas gl shader only call this function when the dir is not exist */
 656    if (mkdir(dir, default_mode) < 0) return EINA_FALSE;
 657    return EINA_TRUE;
 658 }
 659
 660 static Eina_Bool
 661 _evas_gl_shader_file_exists(const char *file)
 662 {
 663    struct stat st;
 664    if (!file) return EINA_FALSE;
 665    if (stat(file, &st) < 0) return EINA_FALSE;
 666    return EINA_TRUE;
 667 }
 668
 669 static inline Eina_Bool
 670 _evas_gl_shader_file_mkpath_if_not_exists(const char *path)
 671 {
 672    struct stat st;
 673
 674    if (stat(path, &st) < 0)
 675      return _evas_gl_shader_file_mkdir(path);
 676    else if (!S_ISDIR(st.st_mode))
 677      return EINA_FALSE;
 678    else
 679      return EINA_TRUE;
 680 }
 681
 682 static Eina_Bool
 683 _evas_gl_shader_file_mkpath(const char *path)
 684 {
 685    char ss[PATH_MAX];
 686    unsigned int i;
 687
 688    if (_evas_gl_shader_file_is_dir(path)) return EINA_TRUE;
 689
 690    for (i = 0; path[i]; ss[i] = path[i], i++)
 691      {
 692         if (i == sizeof(ss) - 1) return EINA_FALSE;
 693         if ((path[i] == '/') && (i > 0))
 694           {
 695              ss[i] = 0;
 696              if (!_evas_gl_shader_file_mkpath_if_not_exists(ss))
 697                return EINA_FALSE;
 698           }
 699      }
 700    ss[i] = 0;
 701    return _evas_gl_shader_file_mkpath_if_not_exists(ss);
 702 }
 703
 704 static int
 705 _evas_gl_shader_dir_check(char *bin_shader_dir, int num)
 706 {
 707    char *home = NULL;
 708    char *subdir = ".cache/evas_gl_common_shaders";
 709
 710    home = getenv("HOME");
 711    if ((!home) || (!home[0])) return 0;
 712
 713    snprintf(bin_shader_dir, num, "%s/%s", home, subdir);
 714    return _evas_gl_shader_file_exists(bin_shader_dir);
 715 }
 716
 717 static int
 718 _evas_gl_shader_file_check(const char *bin_shader_dir, char *bin_shader_file, int dir_num)
 719 {
 720    char before_name[PATH_MAX];
 721    char after_name[PATH_MAX];
 722    int new_path_len = 0;
 723    int i = 0, j = 0;
 724
 725    char *vendor = NULL;
 726    char *driver = NULL;
 727    char *version = NULL;
 728
 729    vendor = (char *)glGetString(GL_VENDOR);
 730    driver = (char *)glGetString(GL_RENDERER);
 731    version = (char *)glGetString(GL_VERSION);
 732
 733    new_path_len = snprintf(before_name, sizeof(before_name), "%s::%s::%s::%s::binary_shader.eet", vendor, version, driver, MODULE_ARCH);
 734
 735    /* remove '/' from file name */
 736    for (i = 0; i < new_path_len; i++)
 737      {
 738         if (before_name[i] != '/')
 739           {
 740              after_name[j] = before_name[i];
 741              j++;
 742           }
 743      }
 744    after_name[j] = 0;
 745
 746    snprintf(bin_shader_file, dir_num, "%s/%s", bin_shader_dir, after_name);
 747
 748    return _evas_gl_shader_file_exists(bin_shader_file);
 749 }
 750
 751 static int
 752 _evas_gl_common_shader_program_binary_init(Evas_GL_Program *p,
 753                                            const char *pname,
 754                                            Eet_File *ef)
 755 {
 756    int res = 0, num = 0, length = 0;
 757    int *formats = NULL;
 758    void *data = NULL;
 759    GLint ok = 0;
 760
 761    if (!ef) return res;
 762
 763    data = eet_read(ef, pname, &length);
 764    if ((!data) || (length <= 0)) goto finish;
 765
 766    glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &num);
 767    if (num <= 0) goto finish;
 768
 769    formats = calloc(num, sizeof(int));
 770    if (!formats) goto finish;
 771
 772    glGetIntegerv(GL_PROGRAM_BINARY_FORMATS, formats);
 773    if (!formats[0]) goto finish;
 774
 775    p->prog = glCreateProgram();
 776
 777 #if 1
 778    // TODO: invalid rendering error occurs when attempting to use a
 779    // glProgramBinary. in order to render correctly we should create a dummy
 780    // vertex shader.
 781    p->vert = glCreateShader(GL_VERTEX_SHADER);
 782    glAttachShader(p->prog, p->vert);
 783    p->frag = glCreateShader(GL_FRAGMENT_SHADER);
 784    glAttachShader(p->prog, p->frag);
 785 #endif
 786    glsym_glProgramBinary(p->prog, formats[0], data, length);
 787
 788    glBindAttribLocation(p->prog, SHAD_VERTEX, "vertex");
 789    glBindAttribLocation(p->prog, SHAD_COLOR,  "color");
 790    glBindAttribLocation(p->prog, SHAD_TEXUV,  "tex_coord");
 791    glBindAttribLocation(p->prog, SHAD_TEXUV2, "tex_coord2");
 792    glBindAttribLocation(p->prog, SHAD_TEXUV3, "tex_coord3");
 793    glBindAttribLocation(p->prog, SHAD_TEXM,   "tex_coordm");
 794
 795    glGetProgramiv(p->prog, GL_LINK_STATUS, &ok);
 796    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 797    if (!ok)
 798      {
 799         gl_compile_link_error(p->prog, "load a program object");
 800         ERR("Abort load of program (%s)", pname);
 801         goto finish;
 802      }
 803
 804    res = 1;
 805
 806 finish:
 807    if (formats) free(formats);
 808    if (data) free(data);
 809    if ((!res) && (p->prog))
 810      {
 811         glDeleteProgram(p->prog);
 812         p->prog = 0;
 813      }
 814    return res;
 815 }
 816
 817 static int
 818 _evas_gl_common_shader_program_binary_save(Evas_GL_Program *p,
 819                                            const char *pname,
 820                                            Eet_File *ef)
 821 {
 822    void* data = NULL;
 823    GLenum format;
 824    int length = 0, size = 0;
 825
 826    if (!glsym_glGetProgramBinary) return 0;
 827
 828    glGetProgramiv(p->prog, GL_PROGRAM_BINARY_LENGTH, &length);
 829    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 830    if (length <= 0) return 0;
 831
 832    data = malloc(length);
 833    if (!data) return 0;
 834
 835    glsym_glGetProgramBinary(p->prog, length, &size, &format, data);
 836    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 837
 838    if (length != size)
 839      {
 840         free(data);
 841         return 0;
 842      }
 843
 844    if (eet_write(ef, pname, data, length, 0) < 0)
 845      {
 846         if (data) free(data);
 847         return 0;
 848      }
 849    if (data) free(data);
 850    return 1;
 851 }
 852
 853 static int
 854 _evas_gl_common_shader_program_source_init(Evas_GL_Program *p,
 855                                            Evas_GL_Program_Source *vert,
 856                                            Evas_GL_Program_Source *frag,
 857                                            const char *name)
 858 {
 859    GLint ok;
 860
 861    p->vert = glCreateShader(GL_VERTEX_SHADER);
 862    p->frag = glCreateShader(GL_FRAGMENT_SHADER);
 863 #if defined (GLES_VARIETY_S3C6410)
 864    glShaderBinary(1, &(p->vert), 0, vert->bin, vert->bin_size);
 865    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 866    glShaderBinary(1, &(p->frag), 0, frag->bin, frag->bin_size);
 867    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 868 #else
 869    glShaderSource(p->vert, 1,
 870                   (const char **)&(vert->src), NULL);
 871    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 872    glCompileShader(p->vert);
 873    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 874    ok = 0;
 875    glGetShaderiv(p->vert, GL_COMPILE_STATUS, &ok);
 876    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 877    if (!ok)
 878      {
 879         gl_compile_link_error(p->vert, "compile vertex shader");
 880         ERR("Abort compile of shader vert (%s): %s", name, vert->src);
 881         return 0;
 882      }
 883    glShaderSource(p->frag, 1,
 884                   (const char **)&(frag->src), NULL);
 885    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 886    glCompileShader(p->frag);
 887    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 888    ok = 0;
 889    glGetShaderiv(p->frag, GL_COMPILE_STATUS, &ok);
 890    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 891    if (!ok)
 892      {
 893         gl_compile_link_error(p->frag, "compile fragment shader");
 894         ERR("Abort compile of shader frag (%s): %s", name, frag->src);
 895         return 0;
 896      }
 897 #endif
 898    p->prog = glCreateProgram();
 899 #if defined(GLES_VARIETY_S3C6410) || defined(GLES_VARIETY_SGX)
 900 #else
 901    if ((glsym_glGetProgramBinary) && (glsym_glProgramParameteri))
 902       glsym_glProgramParameteri(p->prog, GL_PROGRAM_BINARY_RETRIEVABLE_HINT,
 903                                 GL_TRUE);
 904 #endif
 905    glAttachShader(p->prog, p->vert);
 906    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 907    glAttachShader(p->prog, p->frag);
 908    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 909
 910    glBindAttribLocation(p->prog, SHAD_VERTEX, "vertex");
 911    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 912    glBindAttribLocation(p->prog, SHAD_COLOR,  "color");
 913    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 914    glBindAttribLocation(p->prog, SHAD_TEXUV,  "tex_coord");
 915    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 916    glBindAttribLocation(p->prog, SHAD_TEXUV2, "tex_coord2");
 917    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 918    glBindAttribLocation(p->prog, SHAD_TEXUV3, "tex_coord3");
 919    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 920    glBindAttribLocation(p->prog, SHAD_TEXM, "tex_coordm");
 921    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 922
 923    glLinkProgram(p->prog);
 924    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 925    ok = 0;
 926    glGetProgramiv(p->prog, GL_LINK_STATUS, &ok);
 927    GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 928    if (!ok)
 929      {
 930         gl_compile_link_error(p->prog, "link fragment and vertex shaders");
 931         ERR("Abort compile of shader frag (%s): %s", name, frag->src);
 932         ERR("Abort compile of shader vert (%s): %s", name, vert->src);
 933         return 0;
 934      }
 935    return 1;
 936 }
 937
 938 static int
 939 _evas_gl_common_shader_source_init(Evas_GL_Shared *shared)
 940 {
 941    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.rect),
 942                                                    &(shader_rect_vert_src),
 943                                                    &(shader_rect_frag_src),
 944                                                    "rect")) return 0;
 945    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.font),
 946                                                    &(shader_font_vert_src),
 947                                                    &(shader_font_frag_src),
 948                                                    "font")) return 0;
 949    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.img),
 950                                                    &(shader_img_vert_src),
 951                                                    &(shader_img_frag_src),
 952                                                    "img")) return 0;
 953    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.img_nomul),
 954                                                    &(shader_img_nomul_vert_src),
 955                                                    &(shader_img_nomul_frag_src),
 956                                                    "img_nomul")) return 0;
 957    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.img_bgra),
 958                                                    &(shader_img_bgra_vert_src),
 959                                                 &(shader_img_bgra_frag_src),
 960                                                    "img_bgra")) return 0;
 961    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.img_bgra_nomul),
 962                                                    &(shader_img_bgra_nomul_vert_src),
 963                                                    &(shader_img_bgra_nomul_frag_src),
 964                                                    "img_bgra_nomul")) return 0;
 965    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.img_mask),
 966                                                    &(shader_img_mask_vert_src),
 967                                                    &(shader_img_mask_frag_src),
 968                                                    "img_mask")) return 0;
 969    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.tex),
 970                                                    &(shader_tex_vert_src),
 971                                                    &(shader_tex_frag_src),
 972                                                    "tex")) return 0;
 973    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.tex_nomul),
 974                                                    &(shader_tex_nomul_vert_src),
 975                                                    &(shader_tex_nomul_frag_src),
 976                                                    "tex_nomul")) return 0;
 977    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.yuv),
 978                                                    &(shader_yuv_vert_src),
 979                                                    &(shader_yuv_frag_src),
 980                                                    "yuv")) return 0;
 981    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.yuv_nomul),
 982                                                    &(shader_yuv_nomul_vert_src),
 983                                                    &(shader_yuv_nomul_frag_src),
 984                                                    "yuv_nomul")) return 0;
 985
 986    /* Most of the filters use the image fragment shader */
 987    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.filter_invert),
 988                                                    &(shader_img_vert_src),
 989                                                    &(shader_filter_invert_frag_src),
 990                                                    "filter_invert")) return 0;
 991    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.filter_invert_nomul),
 992                                                    &(shader_img_vert_src),
 993                                                    &(shader_filter_invert_nomul_frag_src),
 994                                                    "filter_invert_nomul")) return 0;
 995    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.filter_invert_bgra),
 996                                                    &(shader_img_vert_src),
 997                                                    &(shader_filter_invert_bgra_frag_src),
 998                                                    "filter_invert_bgra")) return 0;
 999    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.filter_invert_bgra_nomul),
1000                                                    &(shader_img_vert_src),
1001                                                    &(shader_filter_invert_bgra_nomul_frag_src),
1002                                                    "filter_invert_bgra_nomul")) return 0;
1003
1004    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.filter_sepia),
1005                                                    &(shader_img_vert_src),
1006                                                    &(shader_filter_sepia_frag_src),
1007                                                    "filter_sepia")) return 0;
1008    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.filter_sepia_nomul),
1009                                                    &(shader_img_vert_src),
1010                                                    &(shader_filter_sepia_nomul_frag_src),
1011                                                    "filter_sepia_nomul")) return 0;
1012    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.filter_sepia_bgra),
1013                                                    &(shader_img_vert_src),
1014                                                    &(shader_filter_sepia_bgra_frag_src),
1015                                                    "filter_sepia_bgra")) return 0;
1016    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.filter_sepia_bgra_nomul),
1017                                                    &(shader_img_vert_src),
1018                                                    &(shader_filter_sepia_bgra_nomul_frag_src),
1019                                                    "filter_sepia_bgra_nomul")) return 0;
1020
1021    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.filter_greyscale),
1022                                                    &(shader_img_vert_src),
1023                                                    &(shader_filter_greyscale_frag_src),
1024                                                    "filter_greyscale")) return 0;
1025    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.filter_greyscale_nomul),
1026                                                    &(shader_img_vert_src),
1027                                                    &(shader_filter_greyscale_nomul_frag_src),
1028                                                    "filter_greyscale_nomul")) return 0;
1029    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.filter_greyscale_bgra),
1030                                                    &(shader_img_vert_src),
1031                                                    &(shader_filter_greyscale_bgra_frag_src),
1032                                                    "filter_greyscale_bgra")) return 0;
1033    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.filter_greyscale_bgra_nomul),
1034                                                    &(shader_img_vert_src),
1035                                                    &(shader_filter_greyscale_bgra_nomul_frag_src),
1036                                                    "filter_greyscale_bgra_nomul")) return 0;
1037 #if 0
1038    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.filter_blur),
1039                                                    &(shader_filter_blur_vert_src),
1040                                                    &(shader_filter_blur_frag_src),
1041                                                    "filter_blur")) return 0;
1042    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.filter_blur_nomul),
1043                                                    &(shader_filter_blur_vert_src),
1044                                                    &(shader_filter_blur_nomul_frag_src),
1045                                                    "filter_blur_nomul")) return 0;
1046    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.filter_blur_bgra),
1047                                                    &(shader_filter_blur_vert_src),
1048                                                    &(shader_filter_blur_bgra_frag_src),
1049                                                    "filter_blur_bgra")) return 0;
1050    if (!_evas_gl_common_shader_program_source_init(&(shared->shader.filter_blur_bgra_nomul),
1051                                                    &(shader_filter_blur_vert_src),
1052                                                    &(shader_filter_blur_bgra_nomul_frag_src),
1053                                                    "filter_blur_bgra_nomul")) return 0;
1054 #endif
1055
1056    return 1;
1057 }
1058
1059 static int
1060 _evas_gl_common_shader_binary_init(Evas_GL_Shared *shared)
1061 {
1062    /* check eet */
1063    Eet_File *et = NULL;
1064    char bin_dir_path[PATH_MAX];
1065    char bin_file_path[PATH_MAX];
1066
1067    if (!_evas_gl_shader_dir_check(bin_dir_path, sizeof(bin_dir_path)))
1068       return 0;
1069
1070    if (!_evas_gl_shader_file_check(bin_dir_path, bin_file_path,
1071                                    sizeof(bin_dir_path)))
1072       return 0;
1073
1074    /* use eet */
1075    if (!eet_init()) return 0;
1076    et = eet_open(bin_file_path, EET_FILE_MODE_READ);
1077    if (!et) goto error;
1078
1079    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.rect), "rect", et)) goto error;
1080    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.font), "font", et)) goto error;
1081    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.img), "img", et)) goto error;
1082    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.img_nomul), "img_nomul", et)) goto error;
1083    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.img_bgra), "img_bgra", et)) goto error;
1084    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.img_bgra_nomul), "img_bgra_nomul", et)) goto error;
1085    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.img_mask), "img_mask", et)) goto error;
1086    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.tex), "tex", et)) goto error;
1087    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.tex_nomul),"tex_nomul", et)) goto error;
1088    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.yuv), "yuv", et)) goto error;
1089    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.yuv_nomul), "yuv_nomul", et)) goto error;
1090
1091    /* Most of the filters use the image fragment shader */
1092    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.filter_invert), "filter_invert", et)) goto error;
1093    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.filter_invert_nomul), "filter_invert_nomul", et)) goto error;
1094    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.filter_invert_bgra), "filter_invert_bgra", et)) goto error;
1095    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.filter_invert_bgra_nomul), "filter_invert_bgra_nomul", et)) goto error;
1096
1097    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.filter_sepia), "filter_sepia", et)) goto error;
1098    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.filter_sepia_nomul), "filter_sepia_nomul", et)) goto error;
1099    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.filter_sepia_bgra), "filter_sepia_bgra", et)) goto error;
1100    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.filter_sepia_bgra_nomul), "filter_sepia_bgra_nomul", et)) goto error;
1101
1102    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.filter_greyscale), "filter_greyscale", et)) goto error;
1103    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.filter_greyscale_nomul), "filter_greyscale_nomul", et)) goto error;
1104    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.filter_greyscale_bgra), "filter_greyscale_bgra", et)) goto error;
1105    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.filter_greyscale_bgra_nomul), "filter_greyscale_bgra_nomul", et)) goto error;
1106 #if 0
1107    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.filter_blur), "filter_blur", et)) goto error;
1108    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.filter_blur_nomul), "filter_blur_nomul", et)) goto error;
1109    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.filter_blur_bgra), "filter_blur_bgra", et)) goto error;
1110    if (!_evas_gl_common_shader_program_binary_init(&(shared->shader.filter_blur_bgra_nomul), "filter_blur_bgra_nomul", et)) goto error;
1111 #endif
1112
1113    if (et) eet_close(et);
1114    eet_shutdown();
1115    return 1;
1116
1117 error:
1118    if (et) eet_close(et);
1119    eet_shutdown();
1120    return 0;
1121 }
1122
1123 static int
1124 _evas_gl_common_shader_binary_save(Evas_GL_Shared *shared)
1125 {
1126    /* check eet */
1127    Eet_File *et = NULL; //check eet file
1128    int tmpfd;
1129    int res = 0;
1130    char bin_dir_path[PATH_MAX];
1131    char bin_file_path[PATH_MAX];
1132    char tmp_file[PATH_MAX];
1133
1134    if (!_evas_gl_shader_dir_check(bin_dir_path, sizeof(bin_dir_path)))
1135       res = _evas_gl_shader_file_mkpath(bin_dir_path);
1136    if (!res) return 0; /* we can't make directory */
1137
1138    _evas_gl_shader_file_check(bin_dir_path, bin_file_path,
1139                               sizeof(bin_dir_path));
1140
1141    /* use mkstemp for writing */
1142    snprintf(tmp_file, sizeof(tmp_file), "%s.XXXXXX", bin_file_path);
1143    tmpfd = mkstemp(tmp_file);
1144    if (tmpfd < 0) goto error;
1145    close(tmpfd);
1146
1147    /* use eet */
1148    if (!eet_init()) goto error;
1149
1150    et = eet_open(tmp_file, EET_FILE_MODE_WRITE);
1151    if (!et) goto error;
1152
1153    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.rect), "rect", et)) goto error;
1154    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.font), "font", et)) goto error;
1155    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.img), "img", et)) goto error;
1156    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.img_nomul), "img_nomul", et)) goto error;
1157    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.img_bgra), "img_bgra", et)) goto error;
1158    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.img_bgra_nomul), "img_bgra_nomul", et)) goto error;
1159    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.img_mask), "img_mask", et)) goto error;
1160    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.tex), "tex", et)) goto error;
1161    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.tex_nomul),"tex_nomul", et)) goto error;
1162    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.yuv), "yuv", et)) goto error;
1163    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.yuv_nomul), "yuv_nomul", et)) goto error;
1164    /* Most of the filters use the image fragment shader */
1165    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.filter_invert), "filter_invert", et)) goto error;
1166    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.filter_invert_nomul), "filter_invert_nomul", et)) goto error;
1167    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.filter_invert_bgra), "filter_invert_bgra", et)) goto error;
1168    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.filter_invert_bgra_nomul), "filter_invert_bgra_nomul", et)) goto error;
1169
1170    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.filter_sepia), "filter_sepia", et)) goto error;
1171    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.filter_sepia_nomul), "filter_sepia_nomul", et)) goto error;
1172    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.filter_sepia_bgra), "filter_sepia_bgra", et)) goto error;
1173    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.filter_sepia_bgra_nomul), "filter_sepia_bgra_nomul", et)) goto error;
1174
1175    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.filter_greyscale), "filter_greyscale", et)) goto error;
1176    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.filter_greyscale_nomul), "filter_greyscale_nomul", et)) goto error;
1177    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.filter_greyscale_bgra), "filter_greyscale_bgra", et)) goto error;
1178    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.filter_greyscale_bgra_nomul), "filter_greyscale_bgra_nomul", et)) goto error;
1179 #if 0
1180    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.filter_blur), "filter_blur", et)) goto error;
1181    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.filter_blur_nomul), "filter_blur_nomul", et)) goto error;
1182    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.filter_blur_bgra), "filter_blur_bgra", et)) goto error;
1183    if (!_evas_gl_common_shader_program_binary_save(&(shared->shader.filter_blur_bgra_nomul), "filter_blur_bgra_nomul", et)) goto error;
1184 #endif
1185
1186    if (eet_close(et) != EET_ERROR_NONE) goto error;
1187    if (rename(tmp_file,bin_file_path) < 0) goto error;
1188    eet_shutdown();
1189    return 1;
1190
1191 error:
1192    if (et) eet_close(et);
1193    if (_evas_gl_shader_file_exists(tmp_file)) unlink(tmp_file);
1194    eet_shutdown();
1195    return 0;
1196 }
1197
1198 int
1199 evas_gl_common_shader_program_init(Evas_GL_Shared *shared)
1200 {
1201    // gl support binary shader and get env of binary shader path
1202    if (shared->info.bin_program &&
1203        _evas_gl_common_shader_binary_init(shared)) return 1;
1204    /* compile all shader.*/
1205    if (!_evas_gl_common_shader_source_init(shared)) return 0;
1206    /* success compile all shader. if gl support binary shader, we need to save */
1207    if (shared->info.bin_program) _evas_gl_common_shader_binary_save(shared);
1208    return 1;
1209 }
1210
1211 void
1212 evas_gl_common_shader_program_init_done(void)
1213 {
1214 #if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
1215    glReleaseShaderCompiler();
1216 #endif
1217 }
1218
1219 void
1220 evas_gl_common_shader_program_shutdown(Evas_GL_Program *p)
1221 {
1222    if (p->vert) glDeleteShader(p->vert);
1223    if (p->frag) glDeleteShader(p->frag);
1224    if (p->prog) glDeleteProgram(p->prog);
1225 }