xbmc/TextureCacheJob.h

   1 /*
   2  *  Copyright (C) 2012-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 #pragma once
  10
  11 #include "pictures/PictureScalingAlgorithm.h"
  12 #include "utils/Job.h"
  13
  14 #include <cstddef>
  15 #include <memory>
  16 #include <stdint.h>
  17 #include <string>
  18 #include <vector>
  19
  20 class CTexture;
  21
  22 /*!
  23  \ingroup textures
  24  \brief Simple class for passing texture detail around
  25  */
  26 class CTextureDetails
  27 {
  28 public:
  29   CTextureDetails()
  30   {
  31     id = -1;
  32     width = height = 0;
  33     updateable = false;
  34   };
  35   bool operator==(const CTextureDetails &right) const
  36   {
  37     return (id    == right.id    &&
  38             file  == right.file  &&
  39             width == right.width );
  40   };
  41   int          id;
  42   std::string  file;
  43   std::string  hash;
  44   unsigned int width;
  45   unsigned int height;
  46   bool         updateable;
  47 };
  48
  49 /*!
  50  \ingroup textures
  51  \brief Job class for caching textures
  52
  53  Handles loading and caching of textures.
  54  */
  55 class CTextureCacheJob : public CJob
  56 {
  57 public:
  58   CTextureCacheJob(const std::string &url, const std::string &oldHash = "");
  59   ~CTextureCacheJob() override;
  60
  61   const char* GetType() const override { return kJobTypeCacheImage; }
  62   bool operator==(const CJob *job) const override;
  63   bool DoWork() override;
  64
  65   /*! \brief retrieve a hash for the given image
  66    Combines the size, ctime and mtime of the image file into a "unique" hash
  67    \param url location of the image
  68    \return a hash string for this image
  69    */
  70   bool CacheTexture(std::unique_ptr<CTexture>* texture = nullptr);
  71
  72   static bool ResizeTexture(const std::string &url, uint8_t* &result, size_t &result_size);
  73
  74   std::string m_url;
  75   std::string m_oldHash;
  76   CTextureDetails m_details;
  77 private:
  78   /*! \brief retrieve a hash for the given image
  79    Combines the size, ctime and mtime of the image file into a "unique" hash
  80    \param url location of the image
  81    \return a hash string for this image
  82    */
  83   static std::string GetImageHash(const std::string &url);
  84
  85   /*! \brief Check whether a given URL represents an image that can be updated
  86    We currently don't check http:// and https:// URLs for updates, under the assumption that
  87    a image URL is much more likely to be static and the actual image at the URL is unlikely
  88    to change, so no point checking all the time.
  89    \param url the url to check
  90    \return true if the image given by the URL should be checked for updates, false otherwise
  91    */
  92   bool UpdateableURL(const std::string &url) const;
  93
  94   /*! \brief Decode an image URL to the underlying image, width, height and orientation
  95    \param url wrapped URL of the image
  96    \param width width derived from URL
  97    \param height height derived from URL
  98    \param scalingAlgorithm scaling algorithm derived from URL
  99    \param additional_info additional information, such as "flipped" to flip horizontally
 100    \return URL of the underlying image file.
 101    */
 102   static std::string DecodeImageURL(const std::string &url, unsigned int &width, unsigned int &height, CPictureScalingAlgorithm::Algorithm& scalingAlgorithm, std::string &additional_info);
 103
 104   /*! \brief Load an image at a given target size and orientation.
 105
 106    Doesn't necessarily load the image at the desired size - the loader *may* decide to load it slightly larger
 107    or smaller than the desired size for speed reasons.
 108
 109    \param image the URL of the image file.
 110    \param width the desired maximum width.
 111    \param height the desired maximum height.
 112    \param additional_info extra info for loading, such as whether to flip horizontally.
 113    \return a pointer to a CTexture object, NULL if failed.
 114    */
 115   static std::unique_ptr<CTexture> LoadImage(const std::string& image,
 116                                              unsigned int width,
 117                                              unsigned int height,
 118                                              const std::string& additional_info,
 119                                              bool requirePixels = false);
 120
 121   std::string    m_cachePath;
 122 };
 123
 124 /* \brief Job class for storing the use count of textures
 125  */
 126 class CTextureUseCountJob : public CJob
 127 {
 128 public:
 129   explicit CTextureUseCountJob(const std::vector<CTextureDetails> &textures);
 130
 131   const char* GetType() const override { return "usecount"; }
 132   bool operator==(const CJob *job) const override;
 133   bool DoWork() override;
 134
 135 private:
 136   std::vector<CTextureDetails> m_textures;
 137 };