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