src/ui/controls/FUiCtrl_OverlayAgent.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file                FUiCtrl_OverlayAgent.cpp
  19  * @brief       This file contains implementation of _OverlayAgent class
  20  */
  21
  22 #include <sys/shm.h>
  23 #include <new>
  24
  25 #define OVERLAY_PIXMAP_DUMP 0
  26
  27 #if OVERLAY_PIXMAP_DUMP
  28
  29 extern "C" {
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <X11/Xproto.h>
  34
  35 #include <fcntl.h>
  36 #include <unistd.h>
  37 #include <dri2.h>
  38 #define virtual UICTRL_INTERNAL_VIRTUAL_REDEFINE
  39 #define private UICTRL_INTERNAL_PRIVATE_REDEFINE
  40 #include <libdrm/drm_slp_bufmgr.h>
  41 #undef virtual
  42 #undef private
  43 }
  44 #endif
  45
  46 #include <Ecore_Evas.h>
  47
  48 #include <FBaseResult.h>
  49 #include <FGrpBufferInfo.h>
  50 #include <FGrpRectangle.h>
  51 #include <FGrpFloatRectangle.h>
  52 #include <FGrpBufferInfo.h>
  53 #include <FUiIOrientationEventListener.h>
  54
  55 #include <FMedia_ImageUtil.h>
  56 #include <FGrp_BufferInfoImpl.h>
  57 #include <FIo_RegistryImpl.h>
  58
  59 #include "FUiCtrlOverlayRegion.h"
  60 #include "FUi_CoordinateSystemUtils.h"
  61 #include "FUi_Control.h"
  62 #include "FUiCtrl_OverlayAgent.h"
  63 #include "FUiAnim_EflNode.h"
  64 #include "FUiAnim_ControlVisualElement.h"
  65 #include "FUiAnim_VisualElementSurfaceImpl.h"
  66 #include "FUiAnim_VisualElementImpl.h"
  67
  68 #define B(c,s) ((((unsigned int)(c)) & 0xff) << (s))
  69 #define FOURCC(a,b,c,d) (B(d,24) | B(c,16) | B(b,8) | B(a,0))
  70
  71 using namespace Tizen::Base;
  72 using namespace Tizen::Graphics;
  73 using namespace Tizen::Ui::Animations;
  74 using namespace Tizen::System;
  75 using namespace Tizen::Media;
  76 using namespace Tizen::Io;
  77
  78 namespace
  79 {
  80
  81 const int _ROTATION_0 = 0;
  82 const int _ROTATION_90 = 90;
  83 const int _ROTATION_180 = 180;
  84 const int _ROTATION_270 = 270;
  85 const int _ROTATION_360 = 360;
  86
  87 const wchar_t* _UI_REGISTRY_PATH = L"/usr/etc/system-info.ini";
  88 const wchar_t* _UI_INFO_SESSION = L"UiControlInfo";
  89
  90 #if OVERLAY_PIXMAP_DUMP
  91
  92 drm_slp_bufmgr gBufmgr = null;
  93 int gFileCount = 0;
  94
  95 static void
  96 dump_bmp(const char* pFileName, const void* pData, int width, int height)
  97 {
  98   int i = 0;
  99
 100         struct
 101         {
 102                 unsigned char magic[2];
 103         } bmpfile_magic = { {'B', 'M'} };
 104
 105   struct
 106     {
 107                 unsigned int filesz;
 108                 unsigned short creator1;
 109                 unsigned short creator2;
 110                 unsigned int bmp_offset;
 111   } bmpfile_header = { 0, 0, 0, 0x36 };
 112
 113   struct
 114     {
 115                 unsigned int header_sz;
 116                 unsigned int width;
 117                 unsigned int height;
 118                 unsigned short nplanes;
 119                 unsigned short bitspp;
 120                 unsigned int compress_type;
 121                 unsigned int bmp_bytesz;
 122                 unsigned int hres;
 123                 unsigned int vres;
 124                 unsigned int ncolors;
 125                 unsigned int nimpcolors;
 126   } bmp_dib_v3_header_t = { 0x28, 0, 0, 1, 24, 0, 0, 0, 0, 0, 0 };
 127
 128   unsigned int* pBlocks = null;
 129
 130   FILE* pFile = fopen(pFileName, "w+");
 131   if (pFile == null)
 132     {
 133           SysLog(NID_UI_CTRL, "failed to fopen [%s]", pFileName);
 134     return;
 135     }
 136   else
 137     {
 138                 bmpfile_header.filesz = sizeof(bmpfile_magic) + sizeof(bmpfile_header) + sizeof(bmp_dib_v3_header_t) + width * height * 3;
 139                 bmp_dib_v3_header_t.header_sz = sizeof(bmp_dib_v3_header_t);
 140                 bmp_dib_v3_header_t.width = width;
 141                 bmp_dib_v3_header_t.height = -height;
 142                 bmp_dib_v3_header_t.nplanes = 1;
 143                 bmp_dib_v3_header_t.bmp_bytesz = width * height * 3;
 144
 145                 fwrite(&bmpfile_magic, sizeof(bmpfile_magic), 1, pFile);
 146                 fwrite(&bmpfile_header, sizeof(bmpfile_header), 1, pFile);
 147                 fwrite(&bmp_dib_v3_header_t, sizeof(bmp_dib_v3_header_t), 1, pFile);
 148
 149                 pBlocks = (unsigned int*)pData;
 150                 for (i = 0; i < (height * width); i++)
 151                         fwrite(&pBlocks[i], 3, 1, pFile);
 152
 153                 fclose(pFile);
 154     }
 155
 156   return;
 157 }
 158
 159 static drm_slp_bufmgr
 160 bufmgr_get(Display* pDisplay, Pixmap pixmap)
 161 {
 162         int screen;
 163         int drm_fd;
 164         drm_slp_bufmgr bufmgr;
 165         int eventBase, errorBase;
 166         int dri2Major, dri2Minor;
 167         char* pDriverName, *pDeviceName;
 168         drm_magic_t magic;
 169
 170         screen = DefaultScreen(pDisplay);
 171
 172         /* DRI2 */
 173         if (!DRI2QueryExtension (pDisplay, &eventBase, &errorBase))
 174         {
 175                 SysLog(NID_UI_CTRL, "!!Error : DRI2QueryExtension !!\n");
 176                 return null;
 177         }
 178
 179         if (!DRI2QueryVersion (pDisplay, &dri2Major, &dri2Minor))
 180         {
 181                 SysLog(NID_UI_CTRL, "!!Error : DRI2QueryVersion !!\n");
 182                 return null;
 183         }
 184
 185         if (!DRI2Connect (pDisplay, RootWindow(pDisplay, screen), &pDriverName, &pDeviceName))
 186         {
 187                 SysLog(NID_UI_CTRL, "!!Error : DRI2Connect !!\n");
 188                 return null;
 189         }
 190
 191         SysLog(NID_UI_CTRL, "Open drm device : %s\n", pDeviceName);
 192
 193         /* get the drm_fd though opening the deviceName */
 194         drm_fd = open (pDeviceName, O_RDWR);
 195         if (drm_fd < 0)
 196         {
 197                 SysLog(NID_UI_CTRL, "!!Error : cannot open drm device (%s)\n", pDeviceName);
 198                 return null;
 199         }
 200
 201   /* get the drm magic */
 202   drmGetMagic(drm_fd, &magic);
 203
 204   if (!DRI2Authenticate(pDisplay, RootWindow(pDisplay, screen), magic))
 205     {
 206                 SysLog(NID_UI_CTRL, "!!Error : DRI2Authenticate !!\n");
 207                 close (drm_fd);
 208                 return null;
 209     }
 210
 211         /* drm slp buffer manager init */
 212         bufmgr = drm_slp_bufmgr_init (drm_fd, null);
 213         if (!bufmgr)
 214         {
 215                 SysLog(NID_UI_CTRL, "!!Error : failed to init buffer manager \n");
 216                 close (drm_fd);
 217                 return null;
 218         }
 219
 220         DRI2CreateDrawable (pDisplay, pixmap);
 221
 222         return bufmgr;
 223 }
 224
 225 static void
 226 pixmap_update (Display* pDisplay, drm_slp_bufmgr bufmgr, Pixmap pixmap,
 227                int x, int y, int width, int height)
 228 {
 229         DRI2Buffer* pDri2_buffers = null;
 230         unsigned int attachments[1];
 231         int dri2_count, dri2_out_count;
 232         int dri2_width, dri2_height, dri2_stride;
 233         drm_slp_bo bo;
 234         int opt;
 235         void* pVirtualBuf = null;
 236         char imgFile[100] = {0,};
 237
 238         attachments[0] = DRI2BufferFrontLeft;
 239         dri2_count = 1;
 240         pDri2_buffers = DRI2GetBuffers (pDisplay, pixmap, &dri2_width, &dri2_height,
 241                                                                    attachments, dri2_count, &dri2_out_count);
 242
 243         if (!pDri2_buffers)
 244         {
 245                 SysLog(NID_UI_CTRL, "!!Error : failed to get buffers\n");
 246                 goto update_done;
 247         }
 248
 249         if (!pDri2_buffers[0].name)
 250         {
 251                 SysLog(NID_UI_CTRL, "!!Error : a handle of the dri2 buffer is null \n ");
 252                 goto update_done;
 253         }
 254
 255         SysLog(NID_UI_CTRL, "pDri2_buffers[0].name : %d", pDri2_buffers[0].name);
 256
 257         bo = drm_slp_bo_import(bufmgr, pDri2_buffers[0].name);
 258         if (!bo)
 259         {
 260                 SysLog(NID_UI_CTRL, "!!Error : cannot import bo (key:%d)\n", pDri2_buffers[0].name);
 261                 goto update_done;
 262         }
 263
 264         dri2_stride = pDri2_buffers[0].pitch;
 265
 266         opt = DRM_SLP_OPTION_READ|DRM_SLP_OPTION_WRITE;
 267         pVirtualBuf = (void*)drm_slp_bo_map (bo, DRM_SLP_DEVICE_CPU, opt);
 268         if (!pVirtualBuf)
 269         {
 270                 SysLog(NID_UI_CTRL, "!!Error : failed to map \n");
 271                 goto update_done;
 272         }
 273
 274         memset(imgFile, 0, sizeof(imgFile));
 275         sprintf(imgFile,"./dump%d.bmp", gFileCount++);
 276   dump_bmp(imgFile, pVirtualBuf, dri2_width, dri2_height);
 277
 278 update_done:
 279         if (pVirtualBuf)
 280                 drm_slp_bo_unmap(bo, DRM_SLP_DEVICE_CPU);
 281         if (bo)
 282                 drm_slp_bo_unref(bo);
 283         if (pDri2_buffers)
 284                 free(pDri2_buffers);
 285 }
 286 #endif
 287
 288 bool
 289 _CheckXvExtension(Display* pDisplay, int* pFirstPort, int* pCountPort)
 290 {
 291         unsigned int version = 0;
 292         unsigned int release = 0;
 293         unsigned int requestBase = 0;
 294         unsigned int eventBase = 0;
 295         unsigned int errorBase = 0;
 296         unsigned int i = 0;
 297         unsigned int adaptors = 0;
 298         XvAdaptorInfo* pAdaptorInfo = null;
 299         int ret = Success;
 300         int port = -1;
 301
 302         // query and print Xvideo properties
 303         ret = XvQueryExtension(pDisplay, &version, &release, &requestBase, &eventBase, &errorBase);
 304         if (ret != Success)
 305         {
 306                 if (ret == XvBadExtension)
 307                 {
 308                         SysLog(NID_UI_CTRL, "XvBadExtension returned at XvQueryExtension!");
 309                 }
 310                 else if (ret == XvBadAlloc)
 311                 {
 312                         SysLog(NID_UI_CTRL, "XvBadAlloc returned at XvQueryExtension!");
 313                 }
 314                 else
 315                 {
 316                         SysLog(NID_UI_CTRL, "other error happened at XvQueryExtension!");
 317                 }
 318
 319                 return false;
 320         }
 321
 322 //      SysLog(NID_UI_CTRL, "========================================");
 323 //      SysLog(NID_UI_CTRL, "XvQueryExtension returned the following:");
 324 //      SysLog(NID_UI_CTRL, "version      : %u", version);
 325 //      SysLog(NID_UI_CTRL, "release      : %u", release);
 326 //      SysLog(NID_UI_CTRL, "request_base : %u", requestBase);
 327 //      SysLog(NID_UI_CTRL, "event_base   : %u", eventBase);
 328 //      SysLog(NID_UI_CTRL, "error_base   : %u", errorBase);
 329 //      SysLog(NID_UI_CTRL, "========================================");
 330
 331         ret = XvQueryAdaptors(pDisplay, DefaultRootWindow(pDisplay), &adaptors, &pAdaptorInfo);
 332         if (ret != Success)
 333         {
 334                 if (ret == XvBadExtension)
 335                 {
 336                         SysLog(NID_UI_CTRL, "XvBadExtension returned at XvQueryExtension.");
 337                 }
 338                 else if (ret == XvBadAlloc)
 339                 {
 340                         SysLog(NID_UI_CTRL, "XvBadAlloc returned at XvQueryExtension.");
 341                 }
 342                 else
 343                 {
 344                         SysLog(NID_UI_CTRL, "other error happaned at XvQueryAdaptors.");
 345                 }
 346
 347                 if (pAdaptorInfo != null)
 348                 {
 349                         XvFreeAdaptorInfo(pAdaptorInfo);
 350                 }
 351
 352                 return false;
 353         }
 354
 355 //      SysLog(NID_UI_CTRL, "XvQueryAdaptors returned the following:");
 356 //      SysLog(NID_UI_CTRL, "%d adaptors available.", adaptors);
 357
 358         if (adaptors > 0 && pAdaptorInfo != null)
 359         {
 360                 for (i = 0; i < adaptors; i++)
 361                 {
 362         //              SysLog(NID_UI_CTRL, " name:        %s"
 363         //                                                              " type:        %s%s%s%s%s"
 364         //                                                              " first port:  %ld"
 365         //                                                              " ports:       %ld",
 366         //                                      pAdaptorInfo[i].name,
 367         //                                      (pAdaptorInfo[i].type & XvInputMask) ? "input | " : "",
 368         //                                      (pAdaptorInfo[i].type & XvOutputMask) ? "output | " : "",
 369         //                                      (pAdaptorInfo[i].type & XvVideoMask) ? "video | " : "",
 370         //                                      (pAdaptorInfo[i].type & XvStillMask) ? "still | " : "",
 371         //                                      (pAdaptorInfo[i].type & XvImageMask) ? "image | " : "",
 372         //                                      pAdaptorInfo[i].base_id,
 373         //                                      pAdaptorInfo[i].num_ports);
 374         //
 375         //              SysLog(NID_UI_CTRL, " format list: %d", i);
 376
 377                         for (unsigned int j = 0; j < pAdaptorInfo[i].num_formats; j++)
 378                         {
 379                                 SysLog(NID_UI_CTRL, "depth=%d, visual=%ld",
 380                                                         pAdaptorInfo[i].formats[j].depth,
 381                                                         pAdaptorInfo[i].formats[j].visual_id);
 382                         }
 383
 384                 }
 385
 386                 port = pAdaptorInfo[0].base_id;
 387
 388                 *pFirstPort = port;
 389                 *pCountPort = pAdaptorInfo[0].num_ports;
 390
 391                 SysLog(NID_UI_CTRL, "port : %d", port);
 392         }
 393
 394         if (pAdaptorInfo != null)
 395         {
 396                 XvFreeAdaptorInfo(pAdaptorInfo);
 397         }
 398
 399         if (port == -1)
 400         {
 401                 return false;
 402         }
 403
 404         return true;
 405 }
 406
 407 Tizen::Graphics::FloatRectangle
 408 ConvertToFloat(const Rectangle& rect)
 409 {
 410         return Tizen::Graphics::FloatRectangle((float) rect.x, (float) rect.y, (float) rect.width, (float) rect.height);
 411 }
 412
 413 Eina_Bool
 414 OnPixmapDamaged(void* pData, int type, void* pEvent)
 415 {
 416         Tizen::Ui::Controls::_OverlayAgent* pOverlayAgent = static_cast<Tizen::Ui::Controls::_OverlayAgent*>(pData);
 417
 418         Ecore_X_Event_Damage* pDamageEvent = (Ecore_X_Event_Damage*)pEvent;
 419         SysTryReturn(NID_UI_CTRL, pDamageEvent != null, ECORE_CALLBACK_PASS_ON, E_INVALID_DATA, "[E_INVALID_DATA] pDamageEvent is null.");
 420
 421         Pixmap pixmap = pOverlayAgent->GetPixmap();
 422         if (pDamageEvent->drawable != pixmap)
 423         {
 424                 SysLog(NID_UI_CTRL, "this drawable[%d] is not for my pixmap[%d]", pDamageEvent->drawable, pixmap);
 425                 return ECORE_CALLBACK_PASS_ON;
 426         }
 427
 428         int w = 0;
 429         int h = 0;
 430         Evas_Object* pImageObject = pOverlayAgent->GetPixmapImageObject();
 431         SysTryReturn(NID_UI_CTRL, pImageObject != null, ECORE_CALLBACK_PASS_ON, E_INVALID_DATA, "[E_INVALID_DATA] pImageObject is null.");
 432
 433         evas_object_geometry_get(pImageObject, null, null, &w, &h);
 434         //evas_object_image_pixels_dirty_set(pImageObject, 1);
 435         evas_object_image_fill_set(pImageObject, 0, 0, w, h);
 436         evas_object_image_data_update_add(pImageObject, 0, 0, w, h);
 437
 438 #if OVERLAY_PIXMAP_DUMP
 439                 if (gBufmgr)
 440                 {
 441                           drm_slp_bufmgr_destroy(gBufmgr);
 442                           gBufmgr = null;
 443                 }
 444
 445                 if (gBufmgr == null)
 446                         gBufmgr = bufmgr_get((Display*)ecore_x_display_get(), pixmap);
 447
 448                 if (gBufmgr != null)
 449                 {
 450                         pixmap_update((Display*)ecore_x_display_get(), gBufmgr, pixmap, 0, 0, w, h);
 451                 }
 452                 else
 453                         SysLog(NID_UI_CTRL, "can't get pixmap gBufmgr");
 454
 455                 SysLog(NID_UI_CTRL, "dump pixmap[%d]", pixmap);
 456
 457 #endif
 458
 459         return ECORE_CALLBACK_DONE;
 460 }
 461
 462 } // Anonymous
 463
 464 namespace Tizen { namespace Ui { namespace Controls
 465 {
 466
 467 int _OverlayAgent::overlayAgentcount = 0;
 468 int _OverlayAgent::overlayAgentXvPortCount = 0;
 469 int _OverlayAgent::baseXvPort = 0;
 470 bool    _OverlayAgent::isPortGrapped[]={false,};
 471
 472 int _OverlayAgent::dstRectMinWidth = -1;
 473 int _OverlayAgent::dstRectMinHegith = -1;
 474 int _OverlayAgent::srcRectMinWidth = -1;
 475 int _OverlayAgent::srcRectMinHegith = -1;
 476
 477 _OverlayAgent*
 478 _OverlayAgent::CreateInstanceN(_OverlayAgentStyle style, const _Control& control, const Rectangle& phyBounds)
 479 {
 480         _OverlayAgent* pOverlayAgent = new (std::nothrow) _OverlayAgent(style, control, phyBounds);
 481         SysTryReturn(NID_UI_CTRL, pOverlayAgent, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 482
 483         result r = GetLastResult();
 484         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 485
 486         SetLastResult(E_SUCCESS);
 487
 488         return pOverlayAgent;
 489
 490 CATCH:
 491         delete pOverlayAgent;
 492         return null;
 493 }
 494
 495 _OverlayAgent::_OverlayAgent(_OverlayAgentStyle style, const _Control& control, const Rectangle& bounds)
 496         : __pImageObject(null)
 497         , __pRenderImageObject(null)
 498         , __pSmartObject(null)
 499         , __pixmapDamageHandle(0)
 500         , __pPixmapEventHandler(null)
 501         , __pixmap(0)
 502         , __pVisualElement(null)
 503         , __bgColor(0xff000000)
 504         , __xvPort(-1)
 505         , __grabXvPort(false)
 506         , __colorFormat(0)
 507         , __userRotation(_ROTATION_0)
 508         , __flushRotate(false)
 509         , __udMirroring(0)
 510         , __lrMirroring(0)
 511         , __aspectRatio(false)
 512         , __srcDimension(0, 0)
 513         , __destDimension(0, 0)
 514         , __pixmapPhyRect(0, 0, 0, 0)
 515         , __resizeRect(0, 0, 0, 0)
 516         ,       __style(style)
 517         , __pXvImage(null)
 518         ,       __newColorFormat(0)
 519         , __pShmInfo(null)
 520         , __overlayAgentColorFormat(_OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_ARGB8888)
 521         , __pRefUserByteBuffer(null)
 522         , __pOrgUserByteBuffer(null)
 523         , __orgImgDimension(0, 0)
 524 {
 525         result r = E_SUCCESS;
 526
 527         switch(style)
 528         {
 529         case _OVERLAY_AGENT_STYLE_REGION_SW:
 530         case _OVERLAY_AGENT_STYLE_REGION_GL:
 531                 r = CreateImageObjectForOverlayRegion(control, bounds);
 532                 break;
 533         case _OVERLAY_AGENT_STYLE_PANEL_GL:
 534         case _OVERLAY_AGENT_STYLE_PANEL_SW:
 535                 r = CreateImageObject(control, bounds);
 536                 break;
 537         default:
 538                 r = E_INVALID_ARG;
 539         }
 540
 541         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 542         SysTryReturnVoidResult(NID_UI_CTRL, __pVisualElement != null, E_SYSTEM, "[E_SYSTEM] __pVisualElement is null");
 543
 544         SetLastResult(E_SUCCESS);
 545
 546         overlayAgentcount++;
 547
 548         SysLog(NID_UI_CTRL, "Constructor: overlayAgentcount is [%d]", overlayAgentcount);
 549 }
 550
 551 _OverlayAgent::~_OverlayAgent(void)
 552 {
 553         overlayAgentcount--;
 554
 555         SysLog(NID_UI_CTRL, "Destructor: overlayAgentcount is [%d]", overlayAgentcount);
 556
 557         UngrabXvPort();
 558
 559         if (__pPixmapEventHandler)
 560         {
 561                 ecore_event_handler_del(__pPixmapEventHandler);
 562                 __pPixmapEventHandler = null;
 563         }
 564
 565         if (__pixmapDamageHandle)
 566         {
 567                 ecore_x_damage_free(__pixmapDamageHandle);
 568                 __pixmapDamageHandle = 0;
 569         }
 570
 571         if (__pixmap != 0)
 572         {
 573                 XFreePixmap((Display*)ecore_x_display_get(), __pixmap);
 574                 __pixmap = 0;
 575         }
 576
 577         if (__pShmInfo)
 578         {
 579                 XShmDetach((Display*)ecore_x_display_get(), __pShmInfo);
 580                 shmdt(__pShmInfo->shmaddr);
 581                 shmctl(__pShmInfo->shmid, IPC_RMID, NULL);
 582                 __pShmInfo = null;
 583         }
 584
 585         if (__pXvImage)
 586         {
 587                 XFree(__pXvImage);
 588                 __pXvImage = null;
 589         }
 590
 591         if (__pOrgUserByteBuffer)
 592         {
 593                 delete __pOrgUserByteBuffer;
 594                 __pOrgUserByteBuffer = null;
 595         }
 596
 597         if (__pImageObject)
 598         {
 599                 evas_object_smart_member_del(__pImageObject);
 600                 evas_object_del(__pImageObject);
 601                 __pImageObject = null;
 602         }
 603
 604         if (__pRenderImageObject)
 605         {
 606                 evas_object_smart_member_del(__pRenderImageObject);
 607                 evas_object_del(__pRenderImageObject);
 608                 __pRenderImageObject = null;
 609         }
 610
 611         if ((__style == _OVERLAY_AGENT_STYLE_REGION_SW || __style == _OVERLAY_AGENT_STYLE_REGION_GL)
 612                         && (__pVisualElement != null))
 613         {
 614                 __pVisualElement->Destroy();
 615                 __pVisualElement = null;
 616         }
 617
 618 #if OVERLAY_PIXMAP_DUMP
 619         if (gBufmgr)
 620                 drm_slp_bufmgr_destroy (gBufmgr);
 621 #endif
 622
 623 }
 624
 625 result
 626 _OverlayAgent::Draw(void)
 627 {
 628         result r = E_SUCCESS;
 629
 630         SysTryReturnResult(NID_UI_CTRL, __pRefUserByteBuffer->GetPointer() != null, r, "nothing to draw... userBuffer is null!");
 631
 632         if(__style == _OVERLAY_AGENT_STYLE_REGION_SW || __style == _OVERLAY_AGENT_STYLE_PANEL_SW)
 633                 r = PutEvasImage();
 634         else
 635                 r = PutXvImage();
 636
 637         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r) );
 638
 639         return r;
 640 }
 641
 642
 643 result
 644 _OverlayAgent::GetBufferInfo(BufferInfo& bufferInfo) const
 645 {
 646         int w = 0, h = 0;
 647         evas_object_geometry_get(__pImageObject, NULL, NULL, &w, &h);
 648
 649         bufferInfo.width = w;
 650         bufferInfo.pitch = w;
 651         bufferInfo.height = h;
 652         bufferInfo.bitsPerPixel = 32;
 653         bufferInfo.pixelFormat = PIXEL_FORMAT_ARGB8888;
 654
 655         _BufferInfoImpl* pBufferInfoImpl = _BufferInfoImpl::GetInstance(bufferInfo);
 656
 657         if(__style == _OVERLAY_AGENT_STYLE_REGION_SW || __style == _OVERLAY_AGENT_STYLE_PANEL_SW)
 658         {
 659                 pBufferInfoImpl->SetHandle(_BufferInfoImpl::HANDLE_TYPE_VE_SURFACE, reinterpret_cast<Handle>(__pImageObject));
 660                 SysLog(NID_UI_CTRL,"return evas image object");
 661         }
 662         else
 663         {
 664                 pBufferInfoImpl->SetHandle(_BufferInfoImpl::HANDLE_TYPE_OVERLAY_REGION, __pixmap);
 665                 SysLog(NID_UI_CTRL,"return pixmap ID");
 666         }
 667
 668         pBufferInfoImpl->SetBounds(Rectangle(0, 0, w, h));
 669
 670         return E_SUCCESS;
 671
 672 }
 673
 674 result
 675 _OverlayAgent::SetInputBuffer(const Dimension& destDim, const ByteBuffer& srcBuffer,
 676                                         const Dimension& srcDim, _OverlayAgentBufferPixelFormat srcFormat)
 677 {
 678         SysTryReturn(NID_UI_CTRL, srcBuffer.GetPointer() != null, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] A specified input parameter is invalid.");
 679         SysTryReturn(NID_UI_CTRL, srcBuffer.GetCapacity() > 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] A specified input parameter is invalid.");
 680         SysTryReturn(NID_UI_CTRL, IsValidSourceDimension(srcDim), E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] A specified input parameter is invalid.");
 681         SysTryReturn(NID_UI_CTRL, IsValidDestinationDimension(destDim), E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] A specified input parameter is invalid.");
 682
 683         switch (srcFormat)
 684         {
 685         case _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_ARGB8888:
 686                 __newColorFormat = FOURCC('R','G','B','4');
 687                 break;
 688         case _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_RGB565:
 689                 __newColorFormat = FOURCC('R','G','B','P');
 690                 break;
 691         case _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_YCbCr420_PLANAR:
 692                 __newColorFormat = FOURCC('I','4','2','0');
 693                 break;
 694         case _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_NV12:
 695                 __newColorFormat = FOURCC('N','V','1','2');
 696                 break;
 697         case _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_UYVY:
 698                 __newColorFormat = FOURCC('U','Y','V','Y');
 699                 break;
 700         default:
 701                 SysLogException(NID_UI_CTRL, E_UNSUPPORTED_FORMAT, "The specified pixel format is not supported.");
 702                 return E_UNSUPPORTED_FORMAT;
 703         }
 704
 705         __srcDimension.width = srcDim.width;
 706         __srcDimension.height = srcDim.height;
 707
 708         __destDimension.width = destDim.width;
 709         __destDimension.height = destDim.height;
 710
 711         __overlayAgentColorFormat = srcFormat;
 712         __pRefUserByteBuffer = &srcBuffer;
 713
 714         SysLog(NID_UI_CTRL,"pBuffer : %x, size : %d, __newColorFormat : %x", __pRefUserByteBuffer->GetPointer(), __pRefUserByteBuffer->GetCapacity(), __newColorFormat);
 715
 716         return E_SUCCESS;
 717 }
 718
 719 result
 720 _OverlayAgent::SetRotation(_OverlayAgentRotation rotation)
 721 {
 722         SysTryReturn(NID_UI_CTRL, (rotation < _OVERLAY_AGENT_ROTATION_MAX),
 723                                 E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG)] A specified input parameter [%d] is invalid.", rotation);
 724
 725         int rotate = _ROTATION_0;
 726
 727         switch (rotation)
 728         {
 729         case _OVERLAY_AGENT_ROTATION_NONE:
 730                 // fall through
 731         case _OVERLAY_AGENT_ROTATION_NONE_LR:
 732                 // fall through
 733         case _OVERLAY_AGENT_ROTATION_NONE_UD:
 734                 rotate = _ROTATION_0;
 735                 break;
 736         case _OVERLAY_AGENT_ROTATION_90:
 737                 // fall through
 738         case _OVERLAY_AGENT_ROTATION_90_LR:
 739                 // fall through
 740         case _OVERLAY_AGENT_ROTATION_90_UD:
 741                 rotate = _ROTATION_90;
 742                 break;
 743         case _OVERLAY_AGENT_ROTATION_180:
 744                 // fall through
 745         case _OVERLAY_AGENT_ROTATION_180_LR:
 746                 // fall through
 747         case _OVERLAY_AGENT_ROTATION_180_UD:
 748                 rotate = _ROTATION_180;
 749                 break;
 750         case _OVERLAY_AGENT_ROTATION_270:
 751                 // fall through
 752         case _OVERLAY_AGENT_ROTATION_270_LR:
 753                 // fall through
 754         case _OVERLAY_AGENT_ROTATION_270_UD:
 755                 rotate = _ROTATION_270;
 756                 break;
 757         default:
 758                 rotate = _ROTATION_0;
 759                 break;
 760         }
 761
 762         int udMirroring = 0;
 763         int lrMirroring = 0;
 764
 765         switch (rotation)
 766         {
 767         case _OVERLAY_AGENT_ROTATION_NONE_UD:
 768                 // fall through
 769         case _OVERLAY_AGENT_ROTATION_90_UD:
 770                 // fall through
 771         case _OVERLAY_AGENT_ROTATION_180_UD:
 772                 // fall through
 773         case _OVERLAY_AGENT_ROTATION_270_UD:
 774                 udMirroring = 1;
 775                 lrMirroring = 0;
 776                 break;
 777         case _OVERLAY_AGENT_ROTATION_NONE_LR:
 778                 // fall through
 779         case _OVERLAY_AGENT_ROTATION_90_LR:
 780                 // fall through
 781         case _OVERLAY_AGENT_ROTATION_180_LR:
 782                 // fall through
 783         case _OVERLAY_AGENT_ROTATION_270_LR:
 784                 udMirroring = 0;
 785                 lrMirroring = 1;
 786                 break;
 787         default:
 788                 udMirroring = 0;
 789                 lrMirroring = 0;
 790                 break;
 791         }
 792
 793         __userRotation = rotate;
 794         __udMirroring = udMirroring;
 795         __lrMirroring = lrMirroring;
 796         __flushRotate = true;
 797
 798         AdjustImageObject();
 799
 800         SysLog(NID_UI_CTRL, "__userRotation[%d], __udMirroring [%d] , __lrMirroring [%d]", __userRotation, __udMirroring, __lrMirroring);
 801
 802         return E_SUCCESS;
 803 }
 804
 805 result
 806 _OverlayAgent::SetDestination(const Dimension& dimension)
 807 {
 808         SysTryReturn(NID_UI_CTRL, IsValidDestinationDimension(dimension), E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] A specified input parameter is invalid.");
 809
 810         Dimension phy = _CoordinateSystemUtils::Transform(Dimension(dimension.width, dimension.height));
 811
 812         __resizeRect.width = phy.width;
 813         __resizeRect.height = phy.height;
 814
 815         SysLog(NID_UI_CTRL, "resizeRect is [%d, %d, %d, %d]",__resizeRect.x, __resizeRect.y, __resizeRect.width, __resizeRect.height);
 816
 817         AdjustImageObject();
 818
 819         return E_SUCCESS;
 820 }
 821
 822 result
 823 _OverlayAgent::SetAspectRatio(bool enable)
 824 {
 825         __aspectRatio = enable;
 826
 827         return E_SUCCESS;
 828 }
 829
 830 result
 831 _OverlayAgent::CreateImageObjectForOverlayRegion(const _Control& control, const Rectangle& phyBounds)
 832 {
 833         _EflNode* pEflNode = null;
 834         Evas_Object* pSmartObject = null;
 835         Evas* pEvas = null;
 836         Ecore_Evas* pEcoreEvas = null;
 837         //Rectangle phyBounds(0,0,0,0);
 838         Rectangle logBounds(0,0,0,0);
 839         VisualElementSurface* pVisualElementSurface = null;
 840         _VisualElementSurfaceImpl* pVisualElementSurfaceImpl = null;
 841         Evas_Object* pTemp = null;
 842
 843         // 1. make VE for OR
 844         _VisualElement* pParentVE = control.GetVisualElement();
 845         SysTryReturn(NID_UI_CTRL, pParentVE != null, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] pParentVE is null.");
 846
 847         _VisualElementImpl* pVisualElementImpl = null;
 848         _VisualElement* pVisualElement = new (std::nothrow) _VisualElement();
 849
 850         SysTryReturn(NID_UI_CTRL, pVisualElement != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pVisualElement : Memory shortage.");
 851
 852         result r = pVisualElement->Construct();
 853         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r) );
 854
 855         pVisualElement->SetName("OverlayRegion");
 856         pVisualElement->SetShowState(true);
 857 //      pVisualElement->SetOpacity(1.0f);
 858         pVisualElement->SetImplicitAnimationEnabled(false);
 859 //      pVisualElement->SetBackgroundColor(_Colorf(0.0f, 0.0f, 0.0f, 0.0f));
 860
 861         pVisualElementImpl = _VisualElementImpl::GetInstance(*pVisualElement);
 862
 863         pVisualElementImpl->SetZOrderGroup(_CONTROL_LAYER_OVERLAY);
 864         r = pParentVE->InsertChild(*pVisualElement, null, true);
 865
 866         logBounds = _CoordinateSystemUtils::InverseTransform(phyBounds);
 867         SysLog(NID_UI_CTRL, "logBounds [%d, %d, %d, %d]", logBounds.x, logBounds.y, logBounds.width, logBounds.height);
 868         pVisualElement->SetBounds(ConvertToFloat(logBounds));
 869
 870         // 2. remove origin VE image object buffer
 871         pVisualElementSurface = pVisualElementImpl->GetSurfaceN();
 872         SysTryCatch(NID_UI_CTRL, pVisualElementSurface != null, , E_SYSTEM, "[E_SYSTEM] pVisualElementSurface is null" );
 873
 874         pVisualElementSurfaceImpl = _VisualElementSurfaceImpl::GetInstance(*pVisualElementSurface);
 875         SysTryCatch(NID_UI_CTRL, pVisualElementSurfaceImpl != null, , E_SYSTEM, "[E_SYSTEM] pVisualElementSurfaceImpl is null" );
 876
 877         pTemp = (Evas_Object*)pVisualElementSurfaceImpl->GetNativeHandle();
 878         SysTryCatch(NID_UI_CTRL, pTemp != null, , E_SYSTEM, "[E_SYSTEM] pTemp is null" );
 879
 880         evas_object_image_data_set(pTemp, NULL);
 881         delete pVisualElementSurface;
 882
 883         // 3. create image object
 884         pEflNode = dynamic_cast<_EflNode*>(pVisualElement->GetNativeNode());
 885         SysTryCatch(NID_UI_CTRL, pEflNode != null, , E_SYSTEM, "[E_SYSTEM] pEflNode is null" );
 886
 887         pSmartObject = (Evas_Object*)pEflNode->GetGroupContainer();
 888         SysTryCatch(NID_UI_CTRL, pSmartObject != null, , E_SYSTEM, "[E_SYSTEM] pSmartObject is null" );
 889
 890         __pSmartObject = pSmartObject;
 891
 892         pEvas = evas_object_evas_get(pSmartObject);
 893         SysTryCatch(NID_UI_CTRL, pEvas != null, , E_SYSTEM, "[E_SYSTEM] pEvas is null" );
 894
 895         pEcoreEvas = ecore_evas_ecore_evas_get(pEvas);
 896         SysTryCatch(NID_UI_CTRL, pEcoreEvas != null, , E_SYSTEM, "[E_SYSTEM] pEcoreEvas is null" );
 897
 898         __pImageObject = evas_object_image_add(pEvas);
 899         SysTryCatch(NID_UI_CTRL, __pImageObject != null, , E_SYSTEM, "[E_SYSTEM] __pImageObject is null" );
 900
 901         // 4. add image obj to smart object
 902         evas_object_smart_member_add(__pImageObject, pSmartObject);
 903         //evas_object_lower(__pImageObject);
 904
 905         SysLog(NID_UI_CTRL, "phyBounds [%d, %d, %d, %d]", phyBounds.x, phyBounds.y, phyBounds.width, phyBounds.height);
 906
 907         evas_object_image_size_set(__pImageObject, phyBounds.width, phyBounds.height);
 908         evas_object_image_filled_set(__pImageObject, EINA_TRUE);
 909         evas_object_image_alpha_set(__pImageObject, false);
 910         evas_object_resize(__pImageObject, phyBounds.width, phyBounds.height);
 911         evas_object_move(__pImageObject, phyBounds.x, phyBounds.y);
 912         evas_object_show(__pImageObject);
 913
 914         r = pVisualElement->SetFlushNeeded();
 915         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 916
 917         __pVisualElement = pVisualElement;
 918
 919         SysLog(NID_UI_CTRL, "ImageObjectForOverlayRegion SUCCESS  __pImageObject : %x, pSmartObject : %x", __pImageObject, pSmartObject);
 920
 921         return E_SUCCESS;
 922
 923 CATCH:
 924         if (__pImageObject)
 925         {
 926                 evas_object_del(__pImageObject);
 927                 __pImageObject = null;
 928         }
 929
 930         if (pVisualElementSurface)
 931         {
 932                 delete pVisualElementSurface;
 933                 pVisualElementSurface = null;
 934         }
 935
 936         if (pVisualElement)
 937         {
 938                 pVisualElement->Destroy();
 939                 pVisualElement = null;
 940         }
 941
 942         return E_SYSTEM;
 943 }
 944
 945 result
 946 _OverlayAgent::CreateImageObject(const _Control& control, const Rectangle& phyBounds)
 947 {
 948         VisualElementSurface* pVisualElementSurface = null;
 949         _VisualElementSurfaceImpl* pVisualElementSurfaceImpl = null;
 950         _VisualElement* pVisualElement = null;
 951         _VisualElementImpl* pVisualElementImpl = null;
 952         Evas* pEvas = null;
 953         Evas_Object* pTemp = null;
 954
 955         _EflNode* pEflNode = dynamic_cast<_EflNode*>(control.GetVisualElement()->GetNativeNode());
 956         SysTryReturn(NID_UI_CTRL, pEflNode != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] pEflNode is null.");
 957
 958         Evas_Object* pSmartObject = (Evas_Object*)pEflNode->GetGroupContainer();
 959         SysTryReturn(NID_UI_CTRL, pSmartObject != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] pSmartObject is null.");
 960         __pSmartObject = pSmartObject;
 961
 962         pVisualElement = control.GetVisualElement();
 963         SysTryReturn(NID_UI_CTRL, pVisualElement != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] pVisualElement is null.");
 964
 965         pVisualElementImpl = _VisualElementImpl::GetInstance(*pVisualElement);
 966         SysTryReturn(NID_UI_CTRL, pVisualElementImpl != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] pVisualElementImpl is null.");
 967
 968         pVisualElementSurface = pVisualElementImpl->GetSurfaceN();
 969         SysTryCatch(NID_UI_CTRL, pVisualElementSurface != null, , E_SYSTEM, "[E_SYSTEM] pVisualElementSurface is null" );
 970
 971         pVisualElementSurfaceImpl = _VisualElementSurfaceImpl::GetInstance(*pVisualElementSurface);
 972         SysTryCatch(NID_UI_CTRL, pVisualElementSurfaceImpl != null, , E_SYSTEM, "[E_SYSTEM] pVisualElementSurfaceImpl is null" );
 973
 974         pTemp = (Evas_Object*)pVisualElementSurfaceImpl->GetNativeHandle();
 975         SysTryCatch(NID_UI_CTRL, pTemp != null, , E_SYSTEM, "[E_SYSTEM] pTemp is null" );
 976
 977         evas_object_image_data_set(pTemp, NULL);
 978         delete pVisualElementSurface;
 979         pVisualElementSurface = null;
 980
 981         pEvas = evas_object_evas_get(pSmartObject);
 982         SysTryReturn(NID_UI_CTRL, pEvas != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] pEvas is null" );
 983
 984         // create renderRect object
 985         __pRenderImageObject = evas_object_rectangle_add(pEvas);
 986         SysTryReturn(NID_UI_CTRL, __pRenderImageObject != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] __pRenderImageObject is null");
 987         evas_object_smart_member_add(__pRenderImageObject, pSmartObject);
 988         evas_object_color_set(__pRenderImageObject, 0, 0, 0, 255); // 100% opaque black
 989         evas_object_resize(__pRenderImageObject, phyBounds.width, phyBounds.height);
 990         evas_object_move(__pRenderImageObject, phyBounds.x, phyBounds.y);
 991         evas_object_show(__pRenderImageObject);
 992
 993         // create image object
 994         __pImageObject = evas_object_image_add(pEvas);
 995         //__pImageObject = evas_object_image_filled_add(pEvas);
 996         SysTryCatch(NID_UI_CTRL, __pImageObject != null, , E_SYSTEM, "[E_SYSTEM] __pImageObject is null");
 997
 998         evas_object_smart_member_add(__pImageObject, pSmartObject);
 999         evas_object_image_size_set(__pImageObject, phyBounds.width, phyBounds.height);
1000         evas_object_image_fill_set(__pImageObject, 0, 0, phyBounds.width, phyBounds.height);
1001         evas_object_image_alpha_set(__pImageObject, false);
1002         evas_object_image_filled_set(__pImageObject, EINA_TRUE);
1003         evas_object_resize(__pImageObject, phyBounds.width, phyBounds.height);
1004         evas_object_move(__pImageObject, phyBounds.x, phyBounds.y);
1005         evas_object_show(__pImageObject);
1006
1007         __pVisualElement = control.GetVisualElement();
1008
1009         SysLog(NID_UI_CTRL, "ImageObjectForOverlayPanel SUCCESS");
1010
1011         return E_SUCCESS;
1012
1013 CATCH:
1014
1015         if (pVisualElementSurface)
1016         {
1017                 delete pVisualElementSurface;
1018                 pVisualElementSurface = null;
1019         }
1020
1021         if (__pRenderImageObject)
1022         {
1023                 evas_object_del(__pRenderImageObject);
1024                 __pRenderImageObject = null;
1025         }
1026
1027         return E_SYSTEM;
1028 }
1029
1030 result
1031 _OverlayAgent::CreatePixmap(void)
1032 {
1033         SysTryReturnResult(NID_UI_CTRL, __pImageObject != null, E_SYSTEM, "[E_SYSTEM] __pImageObject is null");
1034
1035         int x = 0;
1036         int y = 0;
1037         int w = 0;
1038         int h = 0;
1039
1040         evas_object_geometry_get(__pImageObject, &x, &y, &w, &h);
1041         SysLog(NID_UI_CTRL,"__pImageObject rect is [%d, %d, %d, %d]", x, y, w, h);
1042
1043         Rectangle phyRect(x, y, w, h);
1044         SysTryReturnResult(NID_UI_CTRL, (phyRect.width >= GetDstRectMinWidth()) && (phyRect.height >= GetDstRectMinHeight()), E_SYSTEM, "[E_SYSTEM] can't make a pixmap. dimension[%d, %d] is not proper",phyRect.width, phyRect.height);
1045
1046 // Create pixmap.
1047         Display *pDisplay = (Display*)ecore_x_display_get();
1048         SysTryReturnResult(NID_UI_CTRL, pDisplay != null, E_SYSTEM, "[E_SYSTEM] pDisplay is null");
1049
1050         __pixmap = XCreatePixmap(pDisplay, DefaultRootWindow(pDisplay), phyRect.width, phyRect.height, DefaultDepth(pDisplay, DefaultScreen(pDisplay)));
1051         SysTryReturnResult(NID_UI_CTRL, __pixmap != 0, E_SYSTEM, "[E_SYSTEM] failed to create a pixmap");
1052
1053         GC gc = XCreateGC(pDisplay, __pixmap, 0,0);
1054         SysTryReturnResult(NID_UI_CTRL, gc > 0, E_SYSTEM, "[E_SYSTEM] failed to create GC");
1055
1056         XSetForeground(pDisplay, gc, (long unsigned int)(__bgColor.GetRGB32()));
1057         XFillRectangle(pDisplay, __pixmap, gc, 0, 0, phyRect.width, phyRect.height);
1058         XSync(pDisplay, 0);
1059         XFreeGC(pDisplay, gc);
1060
1061 // Set native surface.
1062         Evas_Native_Surface surf = {0,};
1063
1064         surf.version = EVAS_NATIVE_SURFACE_VERSION;
1065         surf.type = EVAS_NATIVE_SURFACE_X11;
1066         surf.data.x11.visual = ecore_x_default_visual_get(ecore_x_display_get(), ecore_x_default_screen_get());
1067         surf.data.x11.pixmap = __pixmap;
1068
1069         evas_object_lower(__pImageObject);
1070         if (__style == _OVERLAY_AGENT_STYLE_PANEL_SW || __style == _OVERLAY_AGENT_STYLE_PANEL_GL)
1071         {
1072                 if(__pRenderImageObject)
1073                 {
1074                         evas_object_lower(__pRenderImageObject);
1075                 }
1076         }
1077
1078         evas_object_image_native_surface_set(__pImageObject, &surf);
1079
1080 // Create damage.
1081         __pixmapDamageHandle = ecore_x_damage_new(__pixmap, ECORE_X_DAMAGE_REPORT_RAW_RECTANGLES);
1082         SysTryCatch(NID_UI_CTRL, __pixmapDamageHandle != 0, , E_SYSTEM, "[E_SYSTEM] failed to create a damage object");
1083
1084         __pPixmapEventHandler = ecore_event_handler_add(ECORE_X_EVENT_DAMAGE_NOTIFY, OnPixmapDamaged, (void*)this);
1085         SysTryCatch(NID_UI_CTRL, __pPixmapEventHandler != null, , E_SYSTEM, "[E_SYSTEM] failed to add a pixmap damage event handle");
1086
1087         __pixmapPhyRect = Rectangle(0, 0, phyRect.width, phyRect.height);
1088
1089         SysLog(NID_UI_CTRL, "__pixmap : %d.", __pixmap);
1090
1091         return E_SUCCESS;
1092
1093 CATCH:
1094         if (__pPixmapEventHandler)
1095         {
1096                 ecore_event_handler_del(__pPixmapEventHandler);
1097                 __pPixmapEventHandler = null;
1098         }
1099
1100         if (__pixmapDamageHandle)
1101         {
1102                 ecore_x_damage_free(__pixmapDamageHandle);
1103                 __pixmapDamageHandle = 0;
1104         }
1105
1106         if (__pixmap)
1107         {
1108                 XFreePixmap((Display*)ecore_x_display_get(), __pixmap);
1109                 __pixmap = 0;
1110         }
1111
1112         return E_SYSTEM;
1113 }
1114
1115 Pixmap
1116 _OverlayAgent::GetPixmap(void) const
1117 {
1118         return __pixmap;
1119 }
1120
1121 Evas_Object*
1122 _OverlayAgent::GetPixmapImageObject(void) const
1123 {
1124         return __pImageObject;
1125 }
1126
1127 result
1128 _OverlayAgent::Show(void) const
1129 {
1130         return E_SUCCESS;
1131 }
1132
1133 result
1134 _OverlayAgent::GrabXvPort(void)
1135 {
1136         int firstXvPort = -1;
1137         int portCount = -1;
1138
1139         Display* pDisplay = (Display*)ecore_x_display_get();
1140         SysTryReturn(NID_UI_CTRL, pDisplay != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1141
1142         if (!_CheckXvExtension(pDisplay, &firstXvPort, &portCount))
1143         {
1144                 SysTryReturn(NID_UI_CTRL, false, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] _CheckXvExtension is failed.");
1145         }
1146
1147         SysTryReturn(NID_UI_CTRL, firstXvPort != -1, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] first XvPort[%d] is invalid.", firstXvPort);
1148         SysTryReturn(NID_UI_CTRL, portCount >= 1 && portCount <= _OVERLAYAGENT_XV_PORT , E_SYSTEM, E_SYSTEM, "[E_SYSTEM] portCount[%d] is invalid.", portCount);
1149
1150         _OverlayAgent::baseXvPort = firstXvPort;
1151
1152         int i, tempPort = 0;
1153         for (i = 0; i < portCount; i++)
1154         {
1155                 if(!isPortGrapped[i])
1156                 {
1157                         tempPort = firstXvPort + i;
1158                         if (XvGrabPort(pDisplay, tempPort, 0) != Success)
1159                         {
1160                                 SysLog(NID_UI_CTRL, "this port[%d] is alreadly used by another process", tempPort);
1161                         }
1162                         else
1163                         {
1164                                 __xvPort = tempPort;
1165                                 __grabXvPort = true;
1166                                 isPortGrapped[i] = true;
1167                                 break;
1168                         }
1169                 }
1170         }
1171
1172         SysTryReturn(NID_UI_CTRL, __xvPort != -1 , E_SYSTEM, E_SYSTEM, "XvGrabPort fail for pixmap : %d", __pixmap);
1173
1174         SysLog(NID_UI_CTRL, "XvGrabPort port: %d pixmap: %d style: %d", __xvPort, __pixmap, __style);
1175
1176         overlayAgentXvPortCount++;
1177
1178         return E_SUCCESS;
1179 }
1180
1181 result
1182 _OverlayAgent::PutXvImage(void)
1183 {
1184         SysTryReturnResult(NID_UI_CTRL, __pixmap != 0, E_SYSTEM, "[E_SYSTEM] __pixmap is invalid. something wrong!");
1185
1186         Display* pDisplay = (Display*)ecore_x_display_get();
1187         SysTryReturn(NID_UI_CTRL, pDisplay != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] pDisplay is null.");
1188
1189         GC gc = DefaultGCOfScreen(DefaultScreenOfDisplay(pDisplay));
1190
1191         bool needRealloc = false;
1192         if (__pXvImage == null || __newColorFormat != __colorFormat /*|| __pXvImage->data_size != __pRefUserByteBuffer->GetCapacity()*/)
1193         {
1194                 needRealloc = true;
1195
1196                 if (__xvPort != -1)
1197                 {
1198                                 SysLog(NID_UI_CTRL, "Need to unGrap port[%d]!", __xvPort);
1199                                 UngrabXvPort();
1200                 }
1201
1202                 if(__pXvImage != null)
1203                 {
1204                         SysLog(NID_UI_CTRL,"pXvImage->data_size : %d, userBufferSize : %d", __pXvImage->data_size, __pRefUserByteBuffer->GetCapacity());
1205                         SysLog(NID_UI_CTRL,"__newColorFormat : %x, __colorFormat : %x", __newColorFormat, __colorFormat);
1206
1207                         if (__pShmInfo)
1208                         {
1209                                 XShmDetach(pDisplay, __pShmInfo);
1210                                 shmdt(__pShmInfo->shmaddr);
1211                                 shmctl(__pShmInfo->shmid, IPC_RMID, NULL);
1212                                 delete __pShmInfo;
1213                                 __pShmInfo = null;
1214                         }
1215
1216                         if (__pXvImage)
1217                         {
1218                                 XFree(__pXvImage);
1219                                 __pXvImage = null;
1220                         }
1221                 }
1222                 else
1223                 {
1224                         SysLog(NID_UI_CTRL, "__pXvImage is null!");
1225                 }
1226         }
1227
1228         if (__xvPort == -1)
1229         {
1230                 SysLog(NID_UI_CTRL, "port[%d] is invalid!", __xvPort);
1231                 result r = GrabXvPort();
1232                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r) );
1233         }
1234
1235         if (needRealloc)
1236         {
1237                 XvImage* pXvImage = null;
1238                 XShmSegmentInfo* pShmInfo = null;
1239
1240                 pShmInfo = new (std::nothrow) XShmSegmentInfo();
1241                 if (pShmInfo == null)
1242                 {
1243                         SysLogException(NID_UI_CTRL, E_SYSTEM, "[E_SYSTEM]pShmInfo is null.");
1244                         return E_SYSTEM;
1245                 }
1246
1247                 pXvImage = XvShmCreateImage(pDisplay, __xvPort, __newColorFormat, 0, __srcDimension.width, __srcDimension.height, pShmInfo);
1248                 SysTryReturn(NID_UI_CTRL, pXvImage != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] failed to create a XvImage.");
1249
1250                 pShmInfo->shmid = shmget(IPC_PRIVATE, pXvImage->data_size, IPC_CREAT | 0777);
1251                 pShmInfo->shmaddr = pXvImage->data = (char*)shmat(pShmInfo->shmid, 0, 0);
1252                 pShmInfo->readOnly = False;
1253
1254                 if (!XShmAttach(pDisplay, pShmInfo))
1255                 {
1256                         XFree(pXvImage);
1257                         SysLogException(NID_UI_CTRL, E_SYSTEM, "[E_SYSTEM] failed to XShmAttach.");
1258                         return E_SYSTEM;
1259                 }
1260
1261                 __pXvImage = pXvImage;
1262                 __pShmInfo = pShmInfo;
1263                 __colorFormat = __newColorFormat;
1264         }
1265
1266         memcpy(__pXvImage->data, __pRefUserByteBuffer->GetPointer(), __pXvImage->data_size);
1267         __pRefUserByteBuffer = null;
1268
1269         Atom rotation = XInternAtom(pDisplay, "_USER_WM_PORT_ATTRIBUTE_ROTATION", False);
1270         XvSetPortAttribute(pDisplay, __xvPort, rotation, 0);
1271
1272         XvShmPutImage(pDisplay, __xvPort, __pixmap, gc, __pXvImage, 0, 0, __srcDimension.width, __srcDimension.height,
1273                         __pixmapPhyRect.x, __pixmapPhyRect.y, __pixmapPhyRect.width, __pixmapPhyRect.height, False);
1274
1275         XSync(pDisplay, 0);
1276
1277         SysLog(NID_UI_CTRL, "colorFormat : %x, src[%d,%d,%d, %d], dst [%d,%d,%d,%d]", __colorFormat, 0, 0, __srcDimension.width, __srcDimension.height,__pixmapPhyRect.x, __pixmapPhyRect.y, __pixmapPhyRect.width, __pixmapPhyRect.height);
1278
1279         return E_SUCCESS;
1280 }
1281
1282 result
1283 _OverlayAgent::PutEvasImage(void)
1284 {
1285         SysTryReturn(NID_UI_CTRL, __pImageObject, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] __pImageObject is null.");
1286         SysTryReturn(NID_UI_CTRL, __pRefUserByteBuffer->GetPointer(), E_SYSTEM, E_SYSTEM, "[E_SYSTEM] __pUserBuffer is null.");
1287
1288         result r = E_SYSTEM;
1289
1290         Dimension usrDim(__srcDimension.width,__srcDimension.height);
1291         if(!usrDim.Equals(__orgImgDimension)
1292                         || __pOrgUserByteBuffer == null
1293                         || __pOrgUserByteBuffer->GetCapacity() != __pRefUserByteBuffer->GetCapacity())
1294         {
1295                 if(__pOrgUserByteBuffer)
1296                 {
1297                         __pOrgUserByteBuffer->SetPosition(0);
1298                         delete __pOrgUserByteBuffer;
1299                         __pOrgUserByteBuffer = null;
1300                 }
1301
1302                 int bufSize = __srcDimension.width *__srcDimension.height * 4;
1303                 __pOrgUserByteBuffer = new (std::nothrow) ByteBuffer;
1304                 SysTryReturn(NID_UI_CTRL, __pOrgUserByteBuffer != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] __pOrgUserByteBuffer is null.");
1305
1306                 r = __pOrgUserByteBuffer->Construct(bufSize);
1307                 if(r != E_SUCCESS)
1308                 {
1309                         SysLogException(NID_UI_CTRL, r, "[%s] Failed to construct a __pOrgUserByteBuffer.", GetErrorMessage(r));
1310                         delete __pOrgUserByteBuffer;
1311                         __pOrgUserByteBuffer = null;
1312                         return r;
1313                 }
1314         }
1315
1316         __pOrgUserByteBuffer->SetPosition(0);
1317
1318         void* pImg = null;
1319         if(__overlayAgentColorFormat == _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_ARGB8888)
1320         {
1321                 r = __pOrgUserByteBuffer->SetArray(__pRefUserByteBuffer->GetPointer(), 0, __pOrgUserByteBuffer->GetCapacity());
1322                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r,"[%s] Propagating.", GetErrorMessage(r));
1323
1324                 pImg = (void*)__pOrgUserByteBuffer->GetPointer();
1325                 //_ImageUtil::ConvertPixelFormat(srcBuffer, MEDIA_PIXEL_FORMAT_RGBA8888, __srcDimension.width, __srcDimension.height, *pDstbuf, MEDIA_PIXEL_FORMAT_RGBA8888);
1326         }
1327         else
1328         {
1329                 switch (__overlayAgentColorFormat)
1330                 {
1331                 case _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_RGB565:
1332                         r = _ImageUtil::ConvertPixelFormat(*__pRefUserByteBuffer, MEDIA_PIXEL_FORMAT_RGB565LE, __srcDimension.width, __srcDimension.height, *__pOrgUserByteBuffer, MEDIA_PIXEL_FORMAT_BGRA8888);
1333                         break;
1334                 case _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_YCbCr420_PLANAR:
1335                         r = _ImageUtil::ConvertPixelFormat(*__pRefUserByteBuffer, MEDIA_PIXEL_FORMAT_YUV420P, __srcDimension.width, __srcDimension.height, *__pOrgUserByteBuffer, MEDIA_PIXEL_FORMAT_BGRA8888);
1336                         break;
1337                 case _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_NV12:
1338                         r = _ImageUtil::ConvertPixelFormat(*__pRefUserByteBuffer, MEDIA_PIXEL_FORMAT_NV12, __srcDimension.width, __srcDimension.height, *__pOrgUserByteBuffer, MEDIA_PIXEL_FORMAT_BGRA8888);
1339                         break;
1340                 case _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_UYVY:
1341                         r = _ImageUtil::ConvertPixelFormat(*__pRefUserByteBuffer, MEDIA_PIXEL_FORMAT_UYVY422, __srcDimension.width, __srcDimension.height, *__pOrgUserByteBuffer, MEDIA_PIXEL_FORMAT_BGRA8888);
1342                         break;
1343                 default:
1344                         SysLogException(NID_UI_CTRL, E_UNSUPPORTED_FORMAT, "The specified pixel format is not supported.");
1345                         return E_UNSUPPORTED_FORMAT;
1346                 }
1347
1348                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r,"[%s] Propagating.", GetErrorMessage(r));
1349
1350                 pImg = (void*)(__pOrgUserByteBuffer->GetPointer());
1351
1352         }
1353
1354         SysTryReturnResult(NID_UI_CTRL, pImg != null, E_SYSTEM, "[E_SYSTEM] converted image data is invalid.");
1355
1356 //      SysLog(NID_UI_CTRL, "__pUserBuffer : %x, size : %d", __pRefUserByteBuffer->GetPointer(),  __pRefUserByteBuffer->GetCapacity());
1357 //      SysLog(NID_UI_CTRL, "__pOrgBuffer : %x, size : %d", __pOrgUserByteBuffer->GetPointer(),  __pOrgUserByteBuffer->GetCapacity());
1358 //      SysLog(NID_UI_CTRL, "__srcDimension[%d, %d]",__srcDimension.width, __srcDimension.height);
1359
1360         evas_object_image_size_set(__pImageObject, __srcDimension.width, __srcDimension.height);
1361         evas_object_image_filled_set(__pImageObject, EINA_TRUE);
1362         evas_object_image_alpha_set(__pImageObject, false);
1363         evas_object_image_data_set(__pImageObject, pImg);
1364         evas_object_image_data_update_add(__pImageObject, 0, 0, __srcDimension.width, __srcDimension.height);
1365         evas_object_show(__pImageObject);
1366
1367         AdjustImageObject();
1368
1369         __pVisualElement->SetFlushNeeded();
1370
1371         __orgImgDimension = usrDim;
1372         __pRefUserByteBuffer = null;
1373
1374         return E_SUCCESS;
1375 }
1376
1377 void
1378 _OverlayAgent::UngrabXvPort(void)
1379 {
1380         if (__grabXvPort)
1381         {
1382                 Display* pDisplay = (Display*) ecore_x_display_get();
1383                 Atom atom = XInternAtom(pDisplay, "_USER_WM_PORT_ATTRIBUTE_STREAM_OFF", False);
1384                 XvSetPortAttribute(pDisplay, __xvPort, atom, 1);
1385                 XvUngrabPort(pDisplay, __xvPort, 0);
1386
1387                 SysLog(NID_UI_CTRL, "UngrabXvPort port: %d pixmap: %d style: %d", __xvPort, __pixmap, __style);
1388
1389                 isPortGrapped[__xvPort-baseXvPort] = false;
1390                 __xvPort = -1;
1391                 __grabXvPort = false;
1392                 overlayAgentXvPortCount--;
1393         }
1394 }
1395
1396 bool
1397 _OverlayAgent::IsValidSourceDimension(const Dimension& dimension) const
1398 {
1399         SysTryReturn(NID_UI_CTRL, dimension.width >= GetSrcRectMinWidth(), false, E_INVALID_ARG, "[E_INVALID_ARG] src width [%d] is invalid.", dimension.width);
1400         SysTryReturn(NID_UI_CTRL, dimension.height >= GetSrcRectMinHeight(), false, E_INVALID_ARG, "[E_INVALID_ARG] src width [%d] is invalid.", dimension.height);
1401
1402         SetLastResult(E_SUCCESS);
1403
1404         return true;
1405 }
1406
1407 bool
1408 _OverlayAgent::IsValidDestinationDimension(const Dimension& dimension) const
1409 {
1410         Dimension phyDim = _CoordinateSystemUtils::Transform(dimension);
1411         SysTryReturn(NID_UI_CTRL, (phyDim.width >= GetDstRectMinWidth() && phyDim.height >= GetDstRectMinHeight()), false, E_INVALID_ARG,
1412                         "[E_INVALID_ARG] Dimension L[%d, %d] P[%d,%d] is over minimun size.", dimension.width, dimension.height, phyDim.width, phyDim.height);
1413
1414         SysTryReturn(NID_UI_CTRL, __pSmartObject != null, false, E_SYSTEM, "[E_SYSTEM] __pSmartObject is null");
1415
1416         FloatRectangle testRect = __pVisualElement->GetBounds();
1417         Dimension containerDim = _CoordinateSystemUtils::Transform(Dimension(static_cast<int>(testRect.width), static_cast<int>(testRect.height)));
1418
1419         SysTryReturn(NID_UI_CTRL, (phyDim.width <= containerDim.width && phyDim.height <= containerDim.height), false, E_INVALID_ARG,
1420                         "[E_INVALID_ARG] RenderRect L[%d, %d] P[%d,%d] is bigger than container size [%d, %d]", dimension.width, dimension.height, phyDim.width, phyDim.height, containerDim.width, containerDim.height);
1421
1422         return true;
1423 }
1424
1425 result
1426 _OverlayAgent::AdjustImageObject(void)
1427 {
1428         SysTryReturn(NID_UI_CTRL, __pSmartObject != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] __pSmartObject is null");
1429         SysTryReturn(NID_UI_CTRL, __pImageObject != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] __pImageObject is null");
1430         SysTryReturn(NID_UI_CTRL, __pVisualElement != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] __pVisualElement is null");
1431
1432         int x = 0;
1433         int y = 0;
1434         int w = 0;
1435         int h = 0;
1436         int resizeRectX = 0;
1437         int resizeRectY = 0;
1438         int resizeRectW = 0;
1439         int resizeRectH = 0;
1440         int noImage = false;
1441         //int orgX, orgY, orgW, orgH;
1442
1443         FloatRectangle curRect = __pVisualElement->GetBounds();
1444         SysLog(NID_UI_CTRL,"curRect [%f, %f, %f, %f]", curRect.x, curRect.y, curRect.width, curRect.height);
1445         Rectangle curPhyRect = _CoordinateSystemUtils::Transform(Rectangle(static_cast<int>(curRect.x), static_cast<int>(curRect.y), static_cast<int>(curRect.width), static_cast<int>(curRect.height)));
1446
1447         if (__srcDimension.width == 0 || __srcDimension.height == 0)
1448         {
1449                 SysLog(NID_UI_CTRL, "src dimension[%d, %d] is an initialized state", __srcDimension.width, __srcDimension.height);
1450                 noImage = true;
1451         }
1452
1453         // 1. setting renderRect resize region
1454         if(__resizeRect.width == 0 || __resizeRect.height == 0)
1455         {
1456                 if (__pRenderImageObject)
1457                 {
1458                         evas_object_geometry_get(__pRenderImageObject, NULL, NULL, &resizeRectW, &resizeRectH);
1459                 }
1460                 else
1461                 {
1462                         resizeRectW = curPhyRect.width;
1463                         resizeRectH = curPhyRect.height;
1464                 }
1465         }
1466         else
1467         {
1468                 resizeRectW = __resizeRect.width;
1469                 resizeRectH = __resizeRect.height;
1470         }
1471
1472         // 2. adjust RenderRect
1473         x = curPhyRect.x;
1474         y = curPhyRect.y;
1475         w = curPhyRect.width;
1476         h = curPhyRect.height;
1477         SysLog(NID_UI_CTRL, "container [%d, %d, %d, %d]", x, y, w, h);
1478
1479         if(__pRenderImageObject)
1480         {
1481 //              evas_object_geometry_get(__pRenderImageObject, &orgX, &orgY, &orgW, &orgH);
1482 //              SysLog(NID_UI_CTRL, "renderRect before [%d, %d, %d, %d]", orgX, orgY, orgW, orgH);
1483
1484                 evas_object_resize(__pRenderImageObject, resizeRectW, resizeRectH);
1485
1486                 resizeRectX = x + ((w - resizeRectW)/2);
1487                 resizeRectY = y + ((h - resizeRectH)/2);
1488                 evas_object_move(__pRenderImageObject, resizeRectX, resizeRectY);
1489                 evas_object_show(__pRenderImageObject);
1490
1491                 SysLog(NID_UI_CTRL, "renderRect [%d, %d, %d, %d]", resizeRectX, resizeRectY, resizeRectW, resizeRectH);
1492
1493 //              evas_object_geometry_get(__pRenderImageObject, &orgX, &orgY, &orgW, &orgH);
1494 //              SysLog(NID_UI_CTRL, "renderRect after adjust [%d, %d, %d, %d]", orgX, orgY, orgW, orgH);
1495         }
1496         else
1497         {
1498                 //evas_object_geometry_get(__pImageObject, &orgX, &orgY, &orgW, &orgH);
1499                 //SysLog(NID_UI_CTRL, "__pImageObject rect [%d, %d, %d, %d]", orgX, orgY, orgW, orgH);
1500
1501                 // set region base x, y
1502                 resizeRectX = x;
1503                 resizeRectY = y;
1504         }
1505
1506         SysLog(NID_UI_CTRL, "resizeRect is [%d, %d, %d, %d]", resizeRectX, resizeRectY, resizeRectW, resizeRectH);
1507
1508         if (__flushRotate)
1509         {
1510                 int finalX, finalY, finalW, finalH;
1511
1512                 SysLog(NID_UI_CTRL, "for rotate status operation");
1513
1514                 // 3. image object rotate
1515                 Evas_Map* pMap = evas_map_new(4);
1516                 evas_map_util_points_populate_from_object(pMap, __pImageObject);
1517
1518                 SysLog(NID_UI_CTRL, "center [%d, %d]", resizeRectX + (resizeRectW/2), resizeRectY + (resizeRectH/2));
1519                 evas_map_util_rotate(pMap, __userRotation, resizeRectX + (resizeRectW/2), resizeRectY + (resizeRectH/2));
1520
1521                 evas_object_map_set(__pImageObject, pMap);
1522                 evas_object_map_enable_set(__pImageObject, EINA_TRUE);
1523
1524                 evas_object_image_filled_set(__pImageObject, EINA_TRUE);
1525                 evas_object_show(__pImageObject);
1526                 evas_map_free(pMap);
1527
1528                 SysLog(NID_UI_CTRL, "rotate value is [%d]",__userRotation);
1529
1530                 // 4. reset map coordinate
1531                 if (!noImage && __aspectRatio && __pRenderImageObject != null)
1532                 {
1533                         //  don't do anything for a Render Rect,  only adjust an image object coordination again
1534                         Dimension srcDim(__srcDimension.width, __srcDimension.height);
1535                         if (__userRotation == _ROTATION_90 || __userRotation == _ROTATION_270 )
1536                         {
1537                                 int tmp = srcDim.width;
1538                                 srcDim.width = srcDim.height;
1539                                 srcDim.height = tmp;
1540 //                      SysLog(NID_UI_CTRL, "src dim is swapped");
1541                         }
1542
1543                         SysLog(NID_UI_CTRL, "src dimension [%d, %d]", srcDim.width, srcDim.height);
1544
1545                         float srcRatio = ((float)srcDim.width) / ((float)srcDim.height);
1546
1547                         float tmpWidth = (float)resizeRectW;
1548                         float tmpHeight = tmpWidth / srcRatio;
1549
1550                         if (resizeRectH < (int)tmpHeight)
1551                         {
1552                                 finalH = resizeRectH;
1553                                 finalW = (int)((float)finalH * srcRatio);
1554                         }
1555                         else
1556                         {
1557                                 finalW = resizeRectW;
1558                                 finalH = (int)((float)finalW / srcRatio);
1559                         }
1560
1561                         finalX = resizeRectX + ((resizeRectW - finalW) / 2);
1562                         finalY = resizeRectY + ((resizeRectH - finalH) / 2);
1563                 }
1564                 else
1565                 {
1566                         finalX = resizeRectX;
1567                         finalY = resizeRectY;
1568                         finalW = resizeRectW;
1569                         finalH = resizeRectH;
1570                 }
1571
1572                 //int p1, p2, p3, p4;
1573                 //evas_object_geometry_get(__pImageObject, &p1, &p2, &p3, &p4);
1574                 //SysLog(NID_UI_CTRL, "__pImageObject after rotate [%d, %d, %d, %d]", p1, p2, p3, p4);
1575
1576                 SysLog(NID_UI_CTRL, "final image object [%d, %d, %d, %d]", finalX, finalY, finalW, finalH);
1577
1578
1579                 pMap = evas_map_new(4);
1580                 evas_map_util_points_populate_from_object(pMap, __pImageObject);
1581
1582                 int imgWidth = 0, imgHeight = 0;
1583                 evas_object_image_size_get(__pImageObject, &imgWidth, &imgHeight);
1584
1585                 switch(__userRotation)
1586                 {
1587                 case _ROTATION_0:
1588                         if(__lrMirroring)
1589                         {
1590                                 evas_map_point_coord_set(pMap, 1, finalX, finalY, 0);
1591                                 evas_map_point_coord_set(pMap, 0, finalX + finalW, finalY, 0);
1592                                 evas_map_point_coord_set(pMap, 3, finalX + finalW, finalY + finalH, 0);
1593                                 evas_map_point_coord_set(pMap, 2, finalX, finalY + finalH, 0);
1594                         }
1595                         else if(__udMirroring)
1596                         {
1597                                 evas_map_point_coord_set(pMap, 3, finalX, finalY, 0);
1598                                 evas_map_point_coord_set(pMap, 2, finalX + finalW, finalY, 0);
1599                                 evas_map_point_coord_set(pMap, 1, finalX + finalW, finalY + finalH, 0);
1600                                 evas_map_point_coord_set(pMap, 0, finalX, finalY + finalH, 0);
1601                         }
1602                         else
1603                         {
1604                                 evas_map_point_coord_set(pMap, 0, finalX, finalY, 0);
1605                                 evas_map_point_coord_set(pMap, 1, finalX + finalW, finalY, 0);
1606                                 evas_map_point_coord_set(pMap, 2, finalX + finalW, finalY + finalH, 0);
1607                                 evas_map_point_coord_set(pMap, 3, finalX, finalY + finalH, 0);
1608                         }
1609                         break;
1610                 case _ROTATION_90:
1611                         if(__lrMirroring)
1612                         {
1613                                 evas_map_point_coord_set(pMap, 2, finalX, finalY, 0);
1614                                 evas_map_point_coord_set(pMap, 1, finalX + finalW, finalY, 0);
1615                                 evas_map_point_coord_set(pMap, 0, finalX + finalW, finalY + finalH, 0);
1616                                 evas_map_point_coord_set(pMap, 3, finalX, finalY + finalH, 0);
1617                         }
1618                         else if(__udMirroring)
1619                         {
1620                                 evas_map_point_coord_set(pMap, 0, finalX, finalY, 0);
1621                                 evas_map_point_coord_set(pMap, 3, finalX + finalW, finalY, 0);
1622                                 evas_map_point_coord_set(pMap, 2, finalX + finalW, finalY + finalH, 0);
1623                                 evas_map_point_coord_set(pMap, 1, finalX, finalY + finalH, 0);
1624                         }
1625                         else
1626                         {
1627                                 evas_map_point_coord_set(pMap, 3, finalX, finalY, 0);
1628                                 evas_map_point_coord_set(pMap, 0, finalX + finalW, finalY, 0);
1629                                 evas_map_point_coord_set(pMap, 1, finalX + finalW, finalY + finalH, 0);
1630                                 evas_map_point_coord_set(pMap, 2, finalX, finalY + finalH, 0);
1631                         }
1632                         break;
1633                 case _ROTATION_180:
1634                         if(__lrMirroring)
1635                         {
1636                                 evas_map_point_coord_set(pMap, 3, finalX, finalY, 0);
1637                                 evas_map_point_coord_set(pMap, 2, finalX + finalW, finalY, 0);
1638                                 evas_map_point_coord_set(pMap, 1, finalX + finalW, finalY + finalH, 0);
1639                                 evas_map_point_coord_set(pMap, 0, finalX, finalY + finalH, 0);
1640                         }
1641                         else if(__udMirroring)
1642                         {
1643                                 evas_map_point_coord_set(pMap, 1, finalX, finalY, 0);
1644                                 evas_map_point_coord_set(pMap, 0, finalX + finalW, finalY, 0);
1645                                 evas_map_point_coord_set(pMap, 3, finalX + finalW, finalY + finalH, 0);
1646                                 evas_map_point_coord_set(pMap, 2, finalX, finalY + finalH, 0);
1647                         }
1648                         else
1649                         {
1650                                 evas_map_point_coord_set(pMap, 2, finalX, finalY, 0);
1651                                 evas_map_point_coord_set(pMap, 3, finalX + finalW, finalY, 0);
1652                                 evas_map_point_coord_set(pMap, 0, finalX + finalW, finalY + finalH, 0);
1653                                 evas_map_point_coord_set(pMap, 1, finalX, finalY + finalH, 0);
1654                         }
1655                         break;
1656                 case _ROTATION_270:
1657                         if(__lrMirroring)
1658                         {
1659                                 evas_map_point_coord_set(pMap, 0, finalX, finalY, 0);
1660                                 evas_map_point_coord_set(pMap, 3, finalX + finalW, finalY, 0);
1661                                 evas_map_point_coord_set(pMap, 2, finalX + finalW, finalY + finalH, 0);
1662                                 evas_map_point_coord_set(pMap, 1, finalX, finalY + finalH, 0);
1663                         }
1664                         else if(__udMirroring)
1665                         {
1666                                 evas_map_point_coord_set(pMap, 2, finalX, finalY, 0);
1667                                 evas_map_point_coord_set(pMap, 1, finalX + finalW, finalY, 0);
1668                                 evas_map_point_coord_set(pMap, 0, finalX + finalW, finalY + finalH, 0);
1669                                 evas_map_point_coord_set(pMap, 3, finalX, finalY + finalH, 0);
1670                         }
1671                         else
1672                         {
1673                                 evas_map_point_coord_set(pMap, 1, finalX, finalY, 0);
1674                                 evas_map_point_coord_set(pMap, 2, finalX + finalW, finalY, 0);
1675                                 evas_map_point_coord_set(pMap, 3, finalX + finalW, finalY + finalH, 0);
1676                                 evas_map_point_coord_set(pMap, 0, finalX, finalY + finalH, 0);
1677                         }
1678                         break;
1679                 default:
1680                         SysLog(NID_UI_CTRL, "__userRotation[%d] is invalid", __userRotation);
1681                         break;
1682                 }
1683
1684                 if(imgWidth > 0 && imgHeight > 0)
1685                 {
1686                         evas_map_point_image_uv_set(pMap, 0, 0, 0);
1687                         evas_map_point_image_uv_set(pMap, 1, imgWidth, 0);
1688                         evas_map_point_image_uv_set(pMap, 2, imgWidth, imgHeight);
1689                         evas_map_point_image_uv_set(pMap, 3, 0, imgHeight);
1690                 }
1691
1692                 evas_object_map_set(__pImageObject, pMap);
1693                 evas_object_map_enable_set(__pImageObject, EINA_TRUE);
1694                 evas_map_free(pMap);
1695
1696                 evas_object_image_filled_set(__pImageObject, EINA_TRUE);
1697                 evas_object_show(__pImageObject);
1698         }
1699         else
1700         {
1701                 SysLog(NID_UI_CTRL, "not for rotate status operation");
1702
1703                 if (!noImage && __aspectRatio && __pRenderImageObject != null)
1704                 {
1705                         Dimension srcDim(__srcDimension.width, __srcDimension.height);
1706                         SysLog(NID_UI_CTRL, "src dimension is [%d, %d]", srcDim.width, srcDim.height);
1707
1708                         float srcRatio = ((float)srcDim.width) / ((float)srcDim.height);
1709                         float tmpWidth = (float)resizeRectW;
1710                         float tmpHeight = tmpWidth / srcRatio;
1711
1712                         Rectangle lastDst;
1713                         if (resizeRectH < (int)tmpHeight)
1714                         {
1715                                 lastDst.height = resizeRectH;
1716                                 lastDst.width = (int)((float)lastDst.height * srcRatio);
1717                         }
1718                         else
1719                         {
1720                                 lastDst.width = resizeRectW;
1721                                 lastDst.height = (int)((float)lastDst.width / srcRatio);
1722                         }
1723
1724                         lastDst.x = resizeRectX + ((resizeRectW - lastDst.width) / 2);
1725                         lastDst.y = resizeRectY + ((resizeRectH - lastDst.height) / 2);
1726
1727 //                      evas_object_geometry_get(__pImageObject, &orgX, &orgY, &orgW, &orgH);
1728 //                      SysLog(NID_UI_CTRL, "__pImageObject before [%d, %d, %d, %d]", orgX, orgY, orgW, orgH);
1729
1730                         evas_object_resize(__pImageObject, lastDst.width, lastDst.height);
1731                         evas_object_move(__pImageObject, lastDst.x, lastDst.y);
1732
1733 //                      evas_object_geometry_get(__pImageObject, &orgX, &orgY, &orgW, &orgH);
1734 //                      SysLog(NID_UI_CTRL, "__pImageObject after [%d, %d, %d, %d]", orgX, orgY, orgW, orgH);
1735
1736                         SysLog(NID_UI_CTRL, "Ratio on / lastDst [%d, %d, %d, %d]",lastDst.x, lastDst.y, lastDst.width, lastDst.height);
1737                 }
1738                 else
1739                 {
1740                         SysLog(NID_UI_CTRL, "Ratio off");
1741
1742                         Evas_Map* pMap = evas_map_new(4);
1743                         evas_map_util_points_populate_from_object(pMap, __pImageObject);
1744
1745                         evas_map_point_coord_set(pMap, 0, resizeRectX, resizeRectY, 0);
1746                         evas_map_point_coord_set(pMap, 1, resizeRectX+resizeRectW, resizeRectY, 0);
1747                         evas_map_point_coord_set(pMap, 2, resizeRectX+resizeRectW, resizeRectY+resizeRectH, 0);
1748                         evas_map_point_coord_set(pMap, 3, resizeRectX, resizeRectY+resizeRectH, 0);
1749
1750                         evas_object_map_set(__pImageObject, pMap);
1751                         evas_object_map_enable_set(__pImageObject, EINA_TRUE);
1752                         evas_map_free(pMap);
1753                 }
1754
1755                 evas_object_image_filled_set(__pImageObject, EINA_TRUE);
1756                 evas_object_show(__pImageObject);
1757         }
1758
1759         __pVisualElement->SetFlushNeeded();
1760
1761         return E_SUCCESS;
1762 }
1763
1764 int
1765 _OverlayAgent::GetOverlayAgentCount(void)
1766 {
1767         return overlayAgentcount;
1768 }
1769
1770 int
1771 _OverlayAgent::GetDstRectMinWidth(void)
1772 {
1773         ClearLastResult();
1774
1775         if (dstRectMinWidth == -1)
1776         {
1777                 result r = E_SUCCESS;
1778                 _RegistryImpl _reg;
1779                 String value;
1780                 int val;
1781
1782                 r = _reg.Construct(_UI_REGISTRY_PATH, REG_OPEN_READ_ONLY, null);
1783                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] RegistryImpl construct Failed");
1784
1785                 r = _reg.GetValue(_UI_INFO_SESSION, L"OverlayDstMinWidth", value);
1786                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] Registry GetValue Failed");
1787
1788                 r = Integer::Parse(value, val);
1789                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] Parse Failed");
1790
1791                 dstRectMinWidth = val;
1792
1793                 SysLog(NID_UI_CTRL, "overlayDstMinWidth : %d", dstRectMinWidth);
1794         }
1795
1796         SetLastResult(E_SUCCESS);
1797
1798         return dstRectMinWidth;
1799 }
1800
1801 int
1802 _OverlayAgent::GetDstRectMinHeight(void)
1803 {
1804         ClearLastResult();
1805
1806         if (dstRectMinHegith == -1)
1807         {
1808                 result r = E_SUCCESS;
1809                 _RegistryImpl _reg;
1810                 String value;
1811                 int val;
1812
1813                 r = _reg.Construct(_UI_REGISTRY_PATH, REG_OPEN_READ_ONLY, null);
1814                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] RegistryImpl construct Failed");
1815
1816                 r = _reg.GetValue(_UI_INFO_SESSION, L"OverlayDstMinHeight", value);
1817                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] Registry GetValue Failed");
1818
1819                 r = Integer::Parse(value, val);
1820                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] Parse Failed");
1821
1822                 dstRectMinHegith = val;
1823
1824                 SysLog(NID_UI_CTRL, "overlayDstMinHeight: %d", dstRectMinHegith);
1825         }
1826
1827         SetLastResult(E_SUCCESS);
1828
1829         return dstRectMinHegith;
1830 }
1831
1832 int
1833 _OverlayAgent::GetSrcRectMinWidth(void)
1834 {
1835         ClearLastResult();
1836
1837         if (srcRectMinWidth == -1)
1838         {
1839                 result r = E_SUCCESS;
1840                 _RegistryImpl _reg;
1841                 String value;
1842                 int val;
1843
1844                 r = _reg.Construct(_UI_REGISTRY_PATH, REG_OPEN_READ_ONLY, null);
1845                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] RegistryImpl construct Failed");
1846
1847                 r = _reg.GetValue(_UI_INFO_SESSION, L"OverlaySrcMinWidth", value);
1848                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] Registry GetValue Failed");
1849
1850                 r = Integer::Parse(value, val);
1851                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] Parse Failed");
1852
1853                 srcRectMinWidth = val;
1854
1855                 SysLog(NID_UI_CTRL, "overlayDstMinWidth : %d", srcRectMinWidth);
1856         }
1857
1858         SetLastResult(E_SUCCESS);
1859
1860         return srcRectMinWidth;
1861 }
1862
1863 int
1864 _OverlayAgent::GetSrcRectMinHeight(void)
1865 {
1866         ClearLastResult();
1867
1868         if (srcRectMinHegith == -1)
1869         {
1870                 result r = E_SUCCESS;
1871                 _RegistryImpl _reg;
1872                 String value;
1873                 int val;
1874
1875                 r = _reg.Construct(_UI_REGISTRY_PATH, REG_OPEN_READ_ONLY, null);
1876                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] RegistryImpl construct Failed");
1877
1878                 r = _reg.GetValue(_UI_INFO_SESSION, L"OverlaySrcMinHeight", value);
1879                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] Registry GetValue Failed");
1880
1881                 r = Integer::Parse(value, val);
1882                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] Parse Failed");
1883
1884                 srcRectMinHegith = val;
1885
1886                 SysLog(NID_UI_CTRL, "overlaySrcMinHeight: %d", srcRectMinHegith);
1887         }
1888
1889         SetLastResult(E_SUCCESS);
1890
1891         return srcRectMinHegith;
1892 }
1893
1894
1895 }}} // Tizen::Ui
1896