Merge pull request xbmc#24845 from CrystalP/fix-bookmarkthumbs

[bookmarks] Fix large and rotated thumbnail creation

Author: CrystalP

xbmc/application/ApplicationPlayer.cpp

@@ -865,6 +865,27 @@ float CApplicationPlayer::GetRenderAspectRatio() const
     return 1.0;
 }
 
+bool CApplicationPlayer::GetRects(CRect& source, CRect& dest, CRect& view) const
+{
+  const std::shared_ptr<const IPlayer> player{GetInternal()};
+  if (player)
+  {
+    player->GetRects(source, dest, view);
+    return true;
+  }
+  else
+    return false;
+}
+
+unsigned int CApplicationPlayer::GetOrientation() const
+{
+  const std::shared_ptr<const IPlayer> player{GetInternal()};
+  if (player)
+    return player->GetOrientation();
+  else
+    return 0;
+}
+
 void CApplicationPlayer::TriggerUpdateResolution()
 {
   std::shared_ptr<IPlayer> player = GetInternal();

xbmc/application/ApplicationPlayer.h

@@ -55,6 +55,8 @@ class CApplicationPlayer : public IApplicationComponent
   void FlushRenderer();
   void SetRenderViewMode(int mode, float zoom, float par, float shift, bool stretch);
   float GetRenderAspectRatio() const;
+  bool GetRects(CRect& source, CRect& dest, CRect& view) const;
+  unsigned int GetOrientation() const;
   void TriggerUpdateResolution();
   bool IsRenderingVideo() const;
   bool IsRenderingGuiLayer() const;

xbmc/cores/IPlayer.h

@@ -231,7 +231,13 @@ class IPlayer
   virtual float GetRenderAspectRatio() const { return 1.0; }
   virtual void TriggerUpdateResolution() {}
   virtual bool IsRenderingVideo() const { return false; }
-
+  virtual void GetRects(CRect& source, CRect& dest, CRect& view) const
+  {
+    source = {};
+    dest = {};
+    view = {};
+  }
+  virtual unsigned int GetOrientation() const { return 0; }
   virtual bool Supports(EINTERLACEMETHOD method) const { return false; }
   virtual EINTERLACEMETHOD GetDeinterlacingMethodDefault() const
   {

xbmc/cores/VideoPlayer/VideoPlayer.cpp

@@ -5034,6 +5034,16 @@ float CVideoPlayer::GetRenderAspectRatio() const
   return m_renderManager.GetAspectRatio();
 }
 
+void CVideoPlayer::GetRects(CRect& source, CRect& dest, CRect& view) const
+{
+  m_renderManager.GetVideoRect(source, dest, view);
+}
+
+unsigned int CVideoPlayer::GetOrientation() const
+{
+  return m_renderManager.GetOrientation();
+}
+
 void CVideoPlayer::TriggerUpdateResolution()
 {
   std::string stereomode;

xbmc/cores/VideoPlayer/VideoPlayer.h

@@ -340,6 +340,8 @@ class CVideoPlayer : public IPlayer, public CThread, public IVideoPlayer,
   void FlushRenderer() override;
   void SetRenderViewMode(int mode, float zoom, float par, float shift, bool stretch) override;
   float GetRenderAspectRatio() const override;
+  void GetRects(CRect& source, CRect& dest, CRect& view) const override;
+  unsigned int GetOrientation() const override;
   void TriggerUpdateResolution() override;
   bool IsRenderingVideo() const override;
   bool Supports(EINTERLACEMETHOD method) const override;

xbmc/cores/VideoPlayer/VideoRenderers/BaseRenderer.h

@@ -85,6 +85,7 @@ class CBaseRenderer
   */
   void GetVideoRect(CRect& source, CRect& dest, CRect& view) const;
   float GetAspectRatio() const;
+  unsigned int GetOrientation() const { return m_renderOrientation; }
 
   static void SettingOptionsRenderMethodsFiller(const std::shared_ptr<const CSetting>& setting,
                                                 std::vector<IntegerSettingOption>& list,

xbmc/cores/VideoPlayer/VideoRenderers/RenderManager.cpp

@@ -70,6 +70,15 @@ float CRenderManager::GetAspectRatio() const
     return 1.0f;
 }
 
+unsigned int CRenderManager::GetOrientation() const
+{
+  std::unique_lock<CCriticalSection> lock(m_statelock);
+  if (m_pRenderer)
+    return m_pRenderer->GetOrientation();
+  else
+    return 0;
+}
+
 void CRenderManager::SetVideoSettings(const CVideoSettings& settings)
 {
   std::unique_lock<CCriticalSection> lock(m_statelock);

xbmc/cores/VideoPlayer/VideoRenderers/RenderManager.h

@@ -60,6 +60,7 @@ class CRenderManager
   // Functions called from render thread
   void GetVideoRect(CRect& source, CRect& dest, CRect& view) const;
   float GetAspectRatio() const;
+  unsigned int GetOrientation() const;
   void FrameMove();
   void FrameWait(std::chrono::milliseconds duration);
   void Render(bool clear, DWORD flags = 0, DWORD alpha = 255, bool gui = true);

xbmc/video/dialogs/GUIDialogVideoBookmarks.cpp

@@ -37,12 +37,11 @@
 #include "video/VideoDatabase.h"
 #include "view/ViewState.h"
 
+#include <algorithm>
 #include <mutex>
 #include <string>
 #include <vector>
 
-#define BOOKMARK_THUMB_WIDTH CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_imageRes
-
 #define CONTROL_ADD_BOOKMARK           2
 #define CONTROL_CLEAR_BOOKMARKS        3
 #define CONTROL_ADD_EPISODE_BOOKMARK   4
@@ -380,16 +379,58 @@ bool CGUIDialogVideoBookmarks::AddBookmark(CVideoInfoTag* tag)
   bookmark.player = g_application.GetCurrentPlayer();
 
   // create the thumbnail image
-  float aspectRatio = appPlayer->GetRenderAspectRatio();
-  int width = BOOKMARK_THUMB_WIDTH;
-  int height = (int)(BOOKMARK_THUMB_WIDTH / aspectRatio);
-  if (height > (int)BOOKMARK_THUMB_WIDTH)
+  const float aspectRatio{appPlayer->GetRenderAspectRatio()};
+  CRect srcRect{}, renderRect{}, viewRect{};
+  appPlayer->GetRects(srcRect, renderRect, viewRect);
+  const unsigned int srcWidth{static_cast<unsigned int>(srcRect.Width())};
+  const unsigned int srcHeight{static_cast<unsigned int>(srcRect.Height())};
+  const unsigned int renderWidth{static_cast<unsigned int>(renderRect.Width())};
+  const unsigned int renderHeight{static_cast<unsigned int>(renderRect.Height())};
+  const unsigned int viewWidth{static_cast<unsigned int>(viewRect.Width())};
+  const unsigned int viewHeight{static_cast<unsigned int>(viewRect.Height())};
+
+  if (!srcWidth || !srcHeight || !renderWidth || !renderHeight || !viewWidth || !viewHeight)
+    return false;
+
+  const unsigned int orientation{appPlayer->GetOrientation()};
+  const bool rotated{orientation == 90 || orientation == 270};
+
+  // FIXME: the renderer sets the scissors to the size of the screen (provided by graphiccontext),
+  // limiting the max size of thumbs (for example 4k video played on 1024x768 screen)
+
+  // The advanced setting defines the max size of the largest dimension (depends on orientation)
+  const unsigned int maxThumbDim{
+      CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_imageRes};
+  unsigned int width{}, height{};
+
+  if (!rotated)
+  {
+    if (aspectRatio >= 1.0f)
+    {
+      width = std::min({maxThumbDim, viewWidth, renderWidth, srcWidth});
+      height = static_cast<unsigned int>(width / aspectRatio);
+    }
+    else
+    {
+      height = std::min({maxThumbDim, viewHeight, renderHeight, srcHeight});
+      width = static_cast<unsigned int>(height * aspectRatio);
+    }
+  }
+  else
   {
-    height = BOOKMARK_THUMB_WIDTH;
-    width = (int)(BOOKMARK_THUMB_WIDTH * aspectRatio);
+    // rotation is applied during rendering, switching source width and height
+    if (aspectRatio >= 1.0f)
+    {
+      height = std::min({maxThumbDim, viewHeight, renderHeight, srcWidth});
+      width = static_cast<unsigned int>(height / aspectRatio);
+    }
+    else
+    {
+      width = std::min({maxThumbDim, viewWidth, renderWidth, srcHeight});
+      height = static_cast<unsigned int>(width * aspectRatio);
+    }
   }
 
-
   uint8_t *pixels = (uint8_t*)malloc(height * width * 4);
   unsigned int captureId = appPlayer->RenderCaptureAlloc();