xbmc/guilib/GUIImage.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "GUIImage.h"
  10
  11 #include "GUIMessage.h"
  12 #include "utils/log.h"
  13
  14 #include <cassert>
  15
  16 using namespace KODI::GUILIB;
  17
  18 CGUIImage::CGUIImage(int parentID,
  19                      int controlID,
  20                      float posX,
  21                      float posY,
  22                      float width,
  23                      float height,
  24                      const CTextureInfo& texture)
  25   : CGUIControl(parentID, controlID, posX, posY, width, height),
  26     m_texture(CGUITexture::CreateTexture(posX, posY, width, height, texture))
  27 {
  28   m_crossFadeTime = 0;
  29   m_currentFadeTime = 0;
  30   m_lastRenderTime = 0;
  31   ControlType = GUICONTROL_IMAGE;
  32   m_bDynamicResourceAlloc=false;
  33 }
  34
  35 CGUIImage::CGUIImage(const CGUIImage& left)
  36   : CGUIControl(left),
  37     m_image(left.m_image),
  38     m_info(left.m_info),
  39     m_texture(left.m_texture->Clone()),
  40     m_fadingTextures(),
  41     m_currentTexture(),
  42     m_currentFallback()
  43 {
  44   m_crossFadeTime = left.m_crossFadeTime;
  45   // defaults
  46   m_currentFadeTime = 0;
  47   m_lastRenderTime = 0;
  48   ControlType = GUICONTROL_IMAGE;
  49   m_bDynamicResourceAlloc=false;
  50 }
  51
  52 CGUIImage::~CGUIImage(void) = default;
  53
  54 void CGUIImage::UpdateVisibility(const CGUIListItem *item)
  55 {
  56   CGUIControl::UpdateVisibility(item);
  57
  58   // now that we've checked for conditional info, we can
  59   // check for allocation
  60   AllocateOnDemand();
  61 }
  62
  63 void CGUIImage::UpdateDiffuseColor(const CGUIListItem* item)
  64 {
  65   if (m_texture->SetDiffuseColor(m_diffuseColor, item))
  66   {
  67     MarkDirtyRegion();
  68   }
  69 }
  70
  71 void CGUIImage::UpdateInfo(const CGUIListItem *item)
  72 {
  73   // The texture may also depend on info conditions. Update the diffuse color in that case.
  74   if (m_texture->GetDiffuseColor().HasInfo())
  75     UpdateDiffuseColor(item);
  76
  77   if (m_info.IsConstant())
  78     return; // nothing to do
  79
  80   // don't allow image to change while animating out
  81   if (HasProcessed() && IsAnimating(ANIM_TYPE_HIDDEN) && !IsVisibleFromSkin())
  82     return;
  83
  84   if (item)
  85     SetFileName(m_info.GetItemLabel(item, true, &m_currentFallback));
  86   else
  87     SetFileName(m_info.GetLabel(m_parentID, true, &m_currentFallback));
  88 }
  89
  90 void CGUIImage::AllocateOnDemand()
  91 {
  92   // if we're hidden, we can free our resources and return
  93   if (!IsVisible() && m_visible != DELAYED)
  94   {
  95     if (m_bDynamicResourceAlloc && m_texture->IsAllocated())
  96       FreeResourcesButNotAnims();
  97     return;
  98   }
  99
 100   // either visible or delayed - we need the resources allocated in either case
 101   if (!m_texture->IsAllocated())
 102     AllocResources();
 103 }
 104
 105 void CGUIImage::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
 106 {
 107   // check whether our image failed to allocate, and if so drop back to the fallback image
 108   if (m_texture->FailedToAlloc() && m_texture->GetFileName() != m_info.GetFallback())
 109   {
 110     if (!m_currentFallback.empty() && m_texture->GetFileName() != m_currentFallback)
 111       m_texture->SetFileName(m_currentFallback);
 112     else
 113       m_texture->SetFileName(m_info.GetFallback());
 114   }
 115
 116   if (m_crossFadeTime)
 117   {
 118     // make sure our texture has started allocating
 119     if (m_texture->AllocResources())
 120       MarkDirtyRegion();
 121
 122     // compute the frame time
 123     unsigned int frameTime = 0;
 124     if (m_lastRenderTime)
 125       frameTime = currentTime - m_lastRenderTime;
 126     if (!frameTime)
 127       frameTime = (unsigned int)(1000 / CServiceBroker::GetWinSystem()->GetGfxContext().GetFPS());
 128     m_lastRenderTime = currentTime;
 129
 130     if (m_fadingTextures.size())  // have some fading images
 131     { // anything other than the last old texture needs to be faded out as per usual
 132       for (std::vector<CFadingTexture *>::iterator i = m_fadingTextures.begin(); i != m_fadingTextures.end() - 1;)
 133       {
 134         if (!ProcessFading(*i, frameTime, currentTime))
 135           i = m_fadingTextures.erase(i);
 136         else
 137           ++i;
 138       }
 139
 140       if (m_texture->ReadyToRender() || m_texture->GetFileName().empty())
 141       { // fade out the last one as well
 142         if (!ProcessFading(m_fadingTextures[m_fadingTextures.size() - 1], frameTime, currentTime))
 143           m_fadingTextures.erase(m_fadingTextures.end() - 1);
 144       }
 145       else
 146       { // keep the last one fading in
 147         CFadingTexture *texture = m_fadingTextures[m_fadingTextures.size() - 1];
 148         texture->m_fadeTime += frameTime;
 149         if (texture->m_fadeTime > m_crossFadeTime)
 150           texture->m_fadeTime = m_crossFadeTime;
 151
 152         if (texture->m_texture->SetAlpha(GetFadeLevel(texture->m_fadeTime)))
 153           MarkDirtyRegion();
 154         if (texture->m_texture->SetDiffuseColor(m_diffuseColor))
 155           MarkDirtyRegion();
 156         if (texture->m_texture->Process(currentTime))
 157           MarkDirtyRegion();
 158       }
 159     }
 160
 161     if (m_texture->ReadyToRender() || m_texture->GetFileName().empty())
 162     { // fade the new one in
 163       m_currentFadeTime += frameTime;
 164       if (m_currentFadeTime > m_crossFadeTime || frameTime == 0) // for if we allocate straight away on creation
 165         m_currentFadeTime = m_crossFadeTime;
 166     }
 167     if (m_texture->SetAlpha(GetFadeLevel(m_currentFadeTime)))
 168       MarkDirtyRegion();
 169   }
 170
 171   if (!m_texture->GetDiffuseColor().HasInfo())
 172     UpdateDiffuseColor(nullptr);
 173
 174   if (m_texture->Process(currentTime))
 175     MarkDirtyRegion();
 176
 177   CGUIControl::Process(currentTime, dirtyregions);
 178 }
 179
 180 void CGUIImage::Render()
 181 {
 182   if (!IsVisible()) return;
 183
 184   for (auto& itr : m_fadingTextures)
 185     itr->m_texture->Render();
 186
 187   m_texture->Render();
 188
 189   CGUIControl::Render();
 190 }
 191
 192 bool CGUIImage::ProcessFading(CGUIImage::CFadingTexture *texture, unsigned int frameTime, unsigned int currentTime)
 193 {
 194   assert(texture);
 195   if (texture->m_fadeTime <= frameTime)
 196   { // time to kill off the texture
 197     MarkDirtyRegion();
 198     delete texture;
 199     return false;
 200   }
 201   // render this texture
 202   texture->m_fadeTime -= frameTime;
 203
 204   if (texture->m_texture->SetAlpha(GetFadeLevel(texture->m_fadeTime)))
 205     MarkDirtyRegion();
 206   if (texture->m_texture->SetDiffuseColor(m_diffuseColor))
 207     MarkDirtyRegion();
 208   if (texture->m_texture->Process(currentTime))
 209     MarkDirtyRegion();
 210
 211   return true;
 212 }
 213
 214 bool CGUIImage::OnAction(const CAction &action)
 215 {
 216   return false;
 217 }
 218
 219 bool CGUIImage::OnMessage(CGUIMessage& message)
 220 {
 221   if (message.GetMessage() == GUI_MSG_REFRESH_THUMBS)
 222   {
 223     if (!m_info.IsConstant())
 224       FreeTextures(true); // true as we want to free the texture immediately
 225     return true;
 226   }
 227   else if (message.GetMessage() == GUI_MSG_SET_FILENAME)
 228   {
 229     SetFileName(message.GetLabel());
 230     return true;
 231   }
 232   else if (message.GetMessage() == GUI_MSG_GET_FILENAME)
 233   {
 234     message.SetLabel(GetFileName());
 235     return true;
 236   }
 237   return CGUIControl::OnMessage(message);
 238 }
 239
 240 void CGUIImage::AllocResources()
 241 {
 242   if (m_texture->GetFileName().empty())
 243     return;
 244
 245   CGUIControl::AllocResources();
 246   m_texture->AllocResources();
 247 }
 248
 249 void CGUIImage::FreeTextures(bool immediately /* = false */)
 250 {
 251   m_texture->FreeResources(immediately);
 252   for (unsigned int i = 0; i < m_fadingTextures.size(); i++)
 253     delete m_fadingTextures[i];
 254   m_fadingTextures.clear();
 255   m_currentTexture.clear();
 256   if (!m_info.IsConstant()) // constant textures never change
 257     m_texture->SetFileName("");
 258 }
 259
 260 void CGUIImage::FreeResources(bool immediately)
 261 {
 262   FreeTextures(immediately);
 263   CGUIControl::FreeResources(immediately);
 264 }
 265
 266 void CGUIImage::SetInvalid()
 267 {
 268   m_texture->SetInvalid();
 269   CGUIControl::SetInvalid();
 270 }
 271
 272 // WORKAROUND - we are currently resetting all animations when this is called, which shouldn't be the case
 273 //              see CGUIControl::FreeResources() - this needs remedying.
 274 void CGUIImage::FreeResourcesButNotAnims()
 275 {
 276   FreeTextures();
 277   m_bAllocated=false;
 278   m_hasProcessed = false;
 279 }
 280
 281 void CGUIImage::DynamicResourceAlloc(bool bOnOff)
 282 {
 283   m_bDynamicResourceAlloc = bOnOff;
 284   m_texture->DynamicResourceAlloc(bOnOff);
 285   CGUIControl::DynamicResourceAlloc(bOnOff);
 286 }
 287
 288 bool CGUIImage::CanFocus() const
 289 {
 290   return false;
 291 }
 292
 293 float CGUIImage::GetTextureWidth() const
 294 {
 295   return m_texture->GetTextureWidth();
 296 }
 297
 298 float CGUIImage::GetTextureHeight() const
 299 {
 300   return m_texture->GetTextureHeight();
 301 }
 302
 303 CRect CGUIImage::CalcRenderRegion() const
 304 {
 305   CRect region = m_texture->GetRenderRect();
 306
 307   for (const auto& itr : m_fadingTextures)
 308     region.Union(itr->m_texture->GetRenderRect());
 309
 310   return CGUIControl::CalcRenderRegion().Intersect(region);
 311 }
 312
 313 const std::string &CGUIImage::GetFileName() const
 314 {
 315   return m_texture->GetFileName();
 316 }
 317
 318 void CGUIImage::SetAspectRatio(const CAspectRatio &aspect)
 319 {
 320   m_texture->SetAspectRatio(aspect);
 321 }
 322
 323 void CGUIImage::SetCrossFade(unsigned int time)
 324 {
 325   m_crossFadeTime = time;
 326   if (!m_crossFadeTime && m_texture->IsLazyLoaded() && !m_info.GetFallback().empty())
 327     m_crossFadeTime = 1;
 328 }
 329
 330 void CGUIImage::SetFileName(const std::string& strFileName, bool setConstant, const bool useCache)
 331 {
 332   if (setConstant)
 333     m_info.SetLabel(strFileName, "", GetParentID());
 334
 335   // Set whether or not to use cache
 336   m_texture->SetUseCache(useCache);
 337
 338   if (m_crossFadeTime)
 339   {
 340     // set filename on the next texture
 341     if (m_currentTexture == strFileName)
 342       return; // nothing to do - we already have this image
 343
 344     if (m_texture->ReadyToRender() || m_texture->GetFileName().empty())
 345     { // save the current image
 346       m_fadingTextures.push_back(new CFadingTexture(m_texture.get(), m_currentFadeTime));
 347       MarkDirtyRegion();
 348     }
 349     m_currentFadeTime = 0;
 350   }
 351   if (m_currentTexture != strFileName)
 352   { // texture is changing - attempt to load it, and save the name in m_currentTexture.
 353     // we'll check whether it loaded or not in Render()
 354     m_currentTexture = strFileName;
 355     if (m_texture->SetFileName(m_currentTexture))
 356       MarkDirtyRegion();
 357   }
 358 }
 359
 360 #ifdef _DEBUG
 361 void CGUIImage::DumpTextureUse()
 362 {
 363   if (m_texture->IsAllocated())
 364   {
 365     if (GetID())
 366       CLog::Log(LOGDEBUG, "Image control {} using texture {}", GetID(), m_texture->GetFileName());
 367     else
 368       CLog::Log(LOGDEBUG, "Using texture {}", m_texture->GetFileName());
 369   }
 370 }
 371 #endif
 372
 373 void CGUIImage::SetWidth(float width)
 374 {
 375   m_texture->SetWidth(width);
 376   CGUIControl::SetWidth(m_texture->GetWidth());
 377 }
 378
 379 void CGUIImage::SetHeight(float height)
 380 {
 381   m_texture->SetHeight(height);
 382   CGUIControl::SetHeight(m_texture->GetHeight());
 383 }
 384
 385 void CGUIImage::SetPosition(float posX, float posY)
 386 {
 387   m_texture->SetPosition(posX, posY);
 388   CGUIControl::SetPosition(posX, posY);
 389 }
 390
 391 void CGUIImage::SetInfo(const GUIINFO::CGUIInfoLabel &info)
 392 {
 393   m_info = info;
 394   // a constant image never needs updating
 395   if (m_info.IsConstant())
 396     m_texture->SetFileName(m_info.GetLabel(0));
 397 }
 398
 399 unsigned char CGUIImage::GetFadeLevel(unsigned int time) const
 400 {
 401   float amount = (float)time / m_crossFadeTime;
 402   // we want a semi-transparent image, so we need to use a more complicated
 403   // fade technique.  Assuming a black background (not generally true, but still...)
 404   // we have
 405   // b(t) = [a - b(1-t)*a] / a*(1-b(1-t)*a),
 406   // where a = alpha, and b(t):[0,1] -> [0,1] is the blend function.
 407   // solving, we get
 408   // b(t) = [1 - (1-a)^t] / a
 409   const float alpha = 0.7f;
 410   return (unsigned char)(255.0f * (1 - pow(1-alpha, amount))/alpha);
 411 }
 412
 413 std::string CGUIImage::GetDescription(void) const
 414 {
 415   return GetFileName();
 416 }
 417