Adding upstream version 2:20.4+dfsg.upstream/2%20.4+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 588 insertions, 0 deletions

diff --git a/xbmc/pictures/Picture.cpp b/xbmc/pictures/Picture.cpp
new file mode 100644
index 0000000..9c7ec1e
--- /dev/null
+++ b/xbmc/pictures/Picture.cpp
@@ -0,0 +1,588 @@
+/*
+ *  Copyright (C) 2005-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include <algorithm>
+
+#include "Picture.h"
+#include "URL.h"
+#include "ServiceBroker.h"
+#include "settings/AdvancedSettings.h"
+#include "settings/Settings.h"
+#include "settings/SettingsComponent.h"
+#include "FileItem.h"
+#include "filesystem/File.h"
+#include "utils/log.h"
+#include "utils/URIUtils.h"
+#include "guilib/Texture.h"
+#include "guilib/imagefactory.h"
+
+extern "C" {
+#include <libswscale/swscale.h>
+}
+
+using namespace XFILE;
+
+bool CPicture::GetThumbnailFromSurface(const unsigned char* buffer, int width, int height, int stride, const std::string &thumbFile, uint8_t* &result, size_t& result_size)
+{
+  unsigned char *thumb = NULL;
+  unsigned int thumbsize = 0;
+
+  // get an image handler
+  IImage* image = ImageFactory::CreateLoader(thumbFile);
+  if (image == NULL ||
+      !image->CreateThumbnailFromSurface(const_cast<unsigned char*>(buffer), width, height,
+                                         XB_FMT_A8R8G8B8, stride, thumbFile, thumb, thumbsize))
+  {
+    delete image;
+    return false;
+  }
+
+  // copy the resulting buffer
+  result_size = thumbsize;
+  result = new uint8_t[result_size];
+  memcpy(result, thumb, result_size);
+
+  // release the image buffer and the image handler
+  image->ReleaseThumbnailBuffer();
+  delete image;
+
+  return true;
+}
+
+bool CPicture::CreateThumbnailFromSurface(const unsigned char *buffer, int width, int height, int stride, const std::string &thumbFile)
+{
+  CLog::Log(LOGDEBUG, "cached image '{}' size {}x{}", CURL::GetRedacted(thumbFile), width, height);
+
+  unsigned char *thumb = NULL;
+  unsigned int thumbsize=0;
+  IImage* pImage = ImageFactory::CreateLoader(thumbFile);
+  if(pImage == NULL || !pImage->CreateThumbnailFromSurface(const_cast<unsigned char*>(buffer), width, height, XB_FMT_A8R8G8B8, stride, thumbFile.c_str(), thumb, thumbsize))
+  {
+    CLog::Log(LOGERROR, "Failed to CreateThumbnailFromSurface for {}",
+              CURL::GetRedacted(thumbFile));
+    delete pImage;
+    return false;
+  }
+
+  XFILE::CFile file;
+  const bool ret = file.OpenForWrite(thumbFile, true) &&
+                   file.Write(thumb, thumbsize) == static_cast<ssize_t>(thumbsize);
+
+  pImage->ReleaseThumbnailBuffer();
+  delete pImage;
+
+  return ret;
+}
+
+CThumbnailWriter::CThumbnailWriter(unsigned char* buffer, int width, int height, int stride, const std::string& thumbFile):
+  m_thumbFile(thumbFile)
+{
+  m_buffer    = buffer;
+  m_width     = width;
+  m_height    = height;
+  m_stride    = stride;
+}
+
+CThumbnailWriter::~CThumbnailWriter()
+{
+  delete m_buffer;
+}
+
+bool CThumbnailWriter::DoWork()
+{
+  bool success = true;
+
+  if (!CPicture::CreateThumbnailFromSurface(m_buffer, m_width, m_height, m_stride, m_thumbFile))
+  {
+    CLog::Log(LOGERROR, "CThumbnailWriter::DoWork unable to write {}",
+              CURL::GetRedacted(m_thumbFile));
+    success = false;
+  }
+
+  delete [] m_buffer;
+  m_buffer = NULL;
+
+  return success;
+}
+
+bool CPicture::ResizeTexture(const std::string& image,
+                             CTexture* texture,
+                             uint32_t& dest_width,
+                             uint32_t& dest_height,
+                             uint8_t*& result,
+                             size_t& result_size,
+                             CPictureScalingAlgorithm::Algorithm
+                                 scalingAlgorithm /* = CPictureScalingAlgorithm::NoAlgorithm */)
+{
+  if (image.empty() || texture == NULL)
+    return false;
+
+  return ResizeTexture(image, texture->GetPixels(), texture->GetWidth(), texture->GetHeight(), texture->GetPitch(),
+                       dest_width, dest_height, result, result_size,
+                       scalingAlgorithm);
+}
+
+bool CPicture::ResizeTexture(const std::string &image, uint8_t *pixels, uint32_t width, uint32_t height, uint32_t pitch,
+  uint32_t &dest_width, uint32_t &dest_height, uint8_t* &result, size_t& result_size,
+  CPictureScalingAlgorithm::Algorithm scalingAlgorithm /* = CPictureScalingAlgorithm::NoAlgorithm */)
+{
+  if (image.empty() || pixels == NULL)
+    return false;
+
+  dest_width = std::min(width, dest_width);
+  dest_height = std::min(height, dest_height);
+
+  // if no max width or height is specified, don't resize
+  if (dest_width == 0 && dest_height == 0)
+  {
+    dest_width = width;
+    dest_height = height;
+  }
+  else if (dest_width == 0)
+  {
+    double factor = (double)dest_height / (double)height;
+    dest_width = (uint32_t)(width * factor);
+  }
+  else if (dest_height == 0)
+  {
+    double factor = (double)dest_width / (double)width;
+    dest_height = (uint32_t)(height * factor);
+  }
+
+  // nothing special to do if the dimensions already match
+  if (dest_width >= width || dest_height >= height)
+    return GetThumbnailFromSurface(pixels, dest_width, dest_height, pitch, image, result, result_size);
+
+  // create a buffer large enough for the resulting image
+  GetScale(width, height, dest_width, dest_height);
+
+  // Let's align so that stride is always divisible by 16, and then add some 32 bytes more on top
+  // See: https://github.com/FFmpeg/FFmpeg/blob/75638fe9402f70645bdde4d95672fa640a327300/libswscale/tests/swscale.c#L157
+  uint32_t dest_width_aligned = ((dest_width + 15) & ~0x0f);
+  uint32_t stride = dest_width_aligned * sizeof(uint32_t);
+
+  uint32_t* buffer = new uint32_t[dest_width_aligned * dest_height + 4];
+  if (buffer == NULL)
+  {
+    result = NULL;
+    result_size = 0;
+    return false;
+  }
+
+  if (!ScaleImage(pixels, width, height, pitch, AV_PIX_FMT_BGRA, (uint8_t*)buffer, dest_width,
+                  dest_height, stride, AV_PIX_FMT_BGRA, scalingAlgorithm))
+  {
+    delete[] buffer;
+    result = NULL;
+    result_size = 0;
+    return false;
+  }
+
+  bool success = GetThumbnailFromSurface((unsigned char*)buffer, dest_width, dest_height, stride,
+                                         image, result, result_size);
+  delete[] buffer;
+
+  if (!success)
+  {
+    result = NULL;
+    result_size = 0;
+  }
+
+  return success;
+}
+
+bool CPicture::CacheTexture(CTexture* texture,
+                            uint32_t& dest_width,
+                            uint32_t& dest_height,
+                            const std::string& dest,
+                            CPictureScalingAlgorithm::Algorithm
+                                scalingAlgorithm /* = CPictureScalingAlgorithm::NoAlgorithm */)
+{
+  return CacheTexture(texture->GetPixels(), texture->GetWidth(), texture->GetHeight(), texture->GetPitch(),
+                      texture->GetOrientation(), dest_width, dest_height, dest, scalingAlgorithm);
+}
+
+bool CPicture::CacheTexture(uint8_t *pixels, uint32_t width, uint32_t height, uint32_t pitch, int orientation,
+  uint32_t &dest_width, uint32_t &dest_height, const std::string &dest,
+  CPictureScalingAlgorithm::Algorithm scalingAlgorithm /* = CPictureScalingAlgorithm::NoAlgorithm */)
+{
+  const std::shared_ptr<CAdvancedSettings> advancedSettings = CServiceBroker::GetSettingsComponent()->GetAdvancedSettings();
+
+  // if no max width or height is specified, don't resize
+  if (dest_width == 0)
+    dest_width = width;
+  if (dest_height == 0)
+    dest_height = height;
+  if (scalingAlgorithm == CPictureScalingAlgorithm::NoAlgorithm)
+    scalingAlgorithm = advancedSettings->m_imageScalingAlgorithm;
+
+  uint32_t max_height = advancedSettings->m_imageRes;
+  if (advancedSettings->m_fanartRes > advancedSettings->m_imageRes)
+  { // 16x9 images larger than the fanart res use that rather than the image res
+    if (fabsf(static_cast<float>(width) / static_cast<float>(height) / (16.0f / 9.0f) - 1.0f)
+        <= 0.01f)
+    {
+      max_height = advancedSettings->m_fanartRes; // use height defined in fanartRes
+    }
+  }
+
+  uint32_t max_width = max_height * 16/9;
+
+  dest_height = std::min(dest_height, max_height);
+  dest_width  = std::min(dest_width, max_width);
+
+  if (width > dest_width || height > dest_height || orientation)
+  {
+    bool success = false;
+
+    dest_width = std::min(width, dest_width);
+    dest_height = std::min(height, dest_height);
+
+    // create a buffer large enough for the resulting image
+    GetScale(width, height, dest_width, dest_height);
+
+    // Let's align so that stride is always divisible by 16, and then add some 32 bytes more on top
+    // See: https://github.com/FFmpeg/FFmpeg/blob/75638fe9402f70645bdde4d95672fa640a327300/libswscale/tests/swscale.c#L157
+    uint32_t dest_width_aligned = ((dest_width + 15) & ~0x0f);
+    uint32_t stride = dest_width_aligned * sizeof(uint32_t);
+
+    uint32_t* buffer = new uint32_t[dest_width_aligned * dest_height + 4];
+    if (buffer)
+    {
+      if (ScaleImage(pixels, width, height, pitch, AV_PIX_FMT_BGRA, (uint8_t*)buffer, dest_width,
+                     dest_height, stride, AV_PIX_FMT_BGRA, scalingAlgorithm))
+      {
+        if (!orientation ||
+            OrientateImage(buffer, dest_width, dest_height, orientation, dest_width_aligned))
+        {
+          success = CreateThumbnailFromSurface((unsigned char*)buffer, dest_width, dest_height,
+                                               dest_width_aligned * 4, dest);
+        }
+      }
+      delete[] buffer;
+    }
+    return success;
+  }
+  else
+  { // no orientation needed
+    dest_width = width;
+    dest_height = height;
+    return CreateThumbnailFromSurface(pixels, width, height, pitch, dest);
+  }
+  return false;
+}
+
+bool CPicture::CreateTiledThumb(const std::vector<std::string> &files, const std::string &thumb)
+{
+  if (!files.size())
+    return false;
+
+  unsigned int num_across = (unsigned int)ceil(sqrt((float)files.size()));
+  unsigned int num_down = (files.size() + num_across - 1) / num_across;
+
+  unsigned int imageRes = CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_imageRes;
+
+  unsigned int tile_width = imageRes / num_across;
+  unsigned int tile_height = imageRes / num_down;
+  unsigned int tile_gap = 1;
+  bool success = false;
+
+  // create a buffer for the resulting thumb
+  uint32_t *buffer = static_cast<uint32_t *>(calloc(imageRes * imageRes, 4));
+  if (!buffer)
+    return false;
+  for (unsigned int i = 0; i < files.size(); ++i)
+  {
+    int x = i % num_across;
+    int y = i / num_across;
+    // load in the image
+    unsigned int width = tile_width - 2*tile_gap, height = tile_height - 2*tile_gap;
+    std::unique_ptr<CTexture> texture = CTexture::LoadFromFile(files[i], width, height, true);
+    if (texture && texture->GetWidth() && texture->GetHeight())
+    {
+      GetScale(texture->GetWidth(), texture->GetHeight(), width, height);
+
+      // scale appropriately
+      uint32_t *scaled = new uint32_t[width * height];
+      if (ScaleImage(texture->GetPixels(), texture->GetWidth(), texture->GetHeight(),
+                     texture->GetPitch(), AV_PIX_FMT_BGRA, (uint8_t*)scaled, width, height,
+                     width * 4, AV_PIX_FMT_BGRA))
+      {
+        unsigned int stridePixels{width};
+        if (!texture->GetOrientation() ||
+            OrientateImage(scaled, width, height, texture->GetOrientation(), stridePixels))
+        {
+          success = true; // Flag that we at least had one successful image processed
+          // drop into the texture
+          unsigned int posX = x*tile_width + (tile_width - width)/2;
+          unsigned int posY = y*tile_height + (tile_height - height)/2;
+          uint32_t *dest = buffer + posX + posY * imageRes;
+          uint32_t *src = scaled;
+          for (unsigned int y = 0; y < height; ++y)
+          {
+            memcpy(dest, src, width*4);
+            dest += imageRes;
+            src += stridePixels;
+          }
+        }
+      }
+      delete[] scaled;
+    }
+  }
+  // now save to a file
+  if (success)
+    success = CreateThumbnailFromSurface((uint8_t *)buffer, imageRes, imageRes, imageRes * 4, thumb);
+
+  free(buffer);
+  return success;
+}
+
+void CPicture::GetScale(unsigned int width, unsigned int height, unsigned int &out_width, unsigned int &out_height)
+{
+  float aspect = (float)width / height;
+  if ((unsigned int)(out_width / aspect + 0.5f) > out_height)
+    out_width = (unsigned int)(out_height * aspect + 0.5f);
+  else
+    out_height = (unsigned int)(out_width / aspect + 0.5f);
+}
+
+bool CPicture::ScaleImage(uint8_t* in_pixels,
+                          unsigned int in_width,
+                          unsigned int in_height,
+                          unsigned int in_pitch,
+                          AVPixelFormat in_format,
+                          uint8_t* out_pixels,
+                          unsigned int out_width,
+                          unsigned int out_height,
+                          unsigned int out_pitch,
+                          AVPixelFormat out_format,
+                          CPictureScalingAlgorithm::Algorithm
+                              scalingAlgorithm /* = CPictureScalingAlgorithm::NoAlgorithm */)
+{
+  struct SwsContext* context =
+      sws_getContext(in_width, in_height, in_format, out_width, out_height, out_format,
+                     CPictureScalingAlgorithm::ToSwscale(scalingAlgorithm), NULL, NULL, NULL);
+
+  uint8_t *src[] = { in_pixels, 0, 0, 0 };
+  int     srcStride[] = { (int)in_pitch, 0, 0, 0 };
+  uint8_t *dst[] = { out_pixels , 0, 0, 0 };
+  int     dstStride[] = { (int)out_pitch, 0, 0, 0 };
+
+  if (context)
+  {
+    sws_scale(context, src, srcStride, 0, in_height, dst, dstStride);
+    sws_freeContext(context);
+    return true;
+  }
+  return false;
+}
+
+bool CPicture::OrientateImage(uint32_t*& pixels,
+                              unsigned int& width,
+                              unsigned int& height,
+                              int orientation,
+                              unsigned int& stridePixels)
+{
+  // ideas for speeding these functions up: http://cgit.freedesktop.org/pixman/tree/pixman/pixman-fast-path.c
+  bool out = false;
+  switch (orientation)
+  {
+    case 1:
+      out = FlipHorizontal(pixels, width, height, stridePixels);
+      break;
+    case 2:
+      out = Rotate180CCW(pixels, width, height, stridePixels);
+      break;
+    case 3:
+      out = FlipVertical(pixels, width, height, stridePixels);
+      break;
+    case 4:
+      out = Transpose(pixels, width, height, stridePixels);
+      break;
+    case 5:
+      out = Rotate270CCW(pixels, width, height, stridePixels);
+      break;
+    case 6:
+      out = TransposeOffAxis(pixels, width, height, stridePixels);
+      break;
+    case 7:
+      out = Rotate90CCW(pixels, width, height, stridePixels);
+      break;
+    default:
+      CLog::Log(LOGERROR, "Unknown orientation {}", orientation);
+      break;
+  }
+  return out;
+}
+
+bool CPicture::FlipHorizontal(uint32_t*& pixels,
+                              const unsigned int& width,
+                              const unsigned int& height,
+                              const unsigned int& stridePixels)
+{
+  // this can be done in-place easily enough
+  for (unsigned int y = 0; y < height; ++y)
+  {
+    uint32_t* line = pixels + y * stridePixels;
+    for (unsigned int x = 0; x < width / 2; ++x)
+      std::swap(line[x], line[width - 1 - x]);
+  }
+  return true;
+}
+
+bool CPicture::FlipVertical(uint32_t*& pixels,
+                            const unsigned int& width,
+                            const unsigned int& height,
+                            const unsigned int& stridePixels)
+{
+  // this can be done in-place easily enough
+  for (unsigned int y = 0; y < height / 2; ++y)
+  {
+    uint32_t* line1 = pixels + y * stridePixels;
+    uint32_t* line2 = pixels + (height - 1 - y) * stridePixels;
+    for (unsigned int x = 0; x < width; ++x)
+      std::swap(*line1++, *line2++);
+  }
+  return true;
+}
+
+bool CPicture::Rotate180CCW(uint32_t*& pixels,
+                            const unsigned int& width,
+                            const unsigned int& height,
+                            const unsigned int& stridePixels)
+{
+  // this can be done in-place easily enough
+  for (unsigned int y = 0; y < height / 2; ++y)
+  {
+    uint32_t* line1 = pixels + y * stridePixels;
+    uint32_t* line2 = pixels + (height - 1 - y) * stridePixels + width - 1;
+    for (unsigned int x = 0; x < width; ++x)
+      std::swap(*line1++, *line2--);
+  }
+  if (height % 2)
+  { // height is odd, so flip the middle row as well
+    uint32_t* line = pixels + (height - 1) / 2 * stridePixels;
+    for (unsigned int x = 0; x < width / 2; ++x)
+      std::swap(line[x], line[width - 1 - x]);
+  }
+  return true;
+}
+
+bool CPicture::Rotate90CCW(uint32_t*& pixels,
+                           unsigned int& width,
+                           unsigned int& height,
+                           unsigned int& stridePixels)
+{
+  uint32_t *dest = new uint32_t[width * height * 4];
+  if (dest)
+  {
+    unsigned int d_height = width, d_width = height;
+    for (unsigned int y = 0; y < d_height; y++)
+    {
+      const uint32_t *src = pixels + (d_height - 1 - y); // y-th col from right, starting at top
+      uint32_t *dst = dest + d_width * y;                // y-th row from top, starting at left
+      for (unsigned int x = 0; x < d_width; x++)
+      {
+        *dst++ = *src;
+        src += stridePixels;
+      }
+    }
+    delete[] pixels;
+    pixels = dest;
+    std::swap(width, height);
+    stridePixels = width;
+    return true;
+  }
+  return false;
+}
+
+bool CPicture::Rotate270CCW(uint32_t*& pixels,
+                            unsigned int& width,
+                            unsigned int& height,
+                            unsigned int& stridePixels)
+{
+  uint32_t *dest = new uint32_t[width * height * 4];
+  if (!dest)
+    return false;
+
+  unsigned int d_height = width, d_width = height;
+  for (unsigned int y = 0; y < d_height; y++)
+  {
+    const uint32_t* src =
+        pixels + stridePixels * (d_width - 1) + y; // y-th col from left, starting at bottom
+    uint32_t* dst = dest + d_width * y; // y-th row from top, starting at left
+    for (unsigned int x = 0; x < d_width; x++)
+    {
+      *dst++ = *src;
+      src -= stridePixels;
+    }
+  }
+
+  delete[] pixels;
+  pixels = dest;
+  std::swap(width, height);
+  stridePixels = width;
+  return true;
+}
+
+bool CPicture::Transpose(uint32_t*& pixels,
+                         unsigned int& width,
+                         unsigned int& height,
+                         unsigned int& stridePixels)
+{
+  uint32_t *dest = new uint32_t[width * height * 4];
+  if (!dest)
+    return false;
+
+  unsigned int d_height = width, d_width = height;
+  for (unsigned int y = 0; y < d_height; y++)
+  {
+    const uint32_t *src = pixels + y;   // y-th col from left, starting at top
+    uint32_t *dst = dest + d_width * y; // y-th row from top, starting at left
+    for (unsigned int x = 0; x < d_width; x++)
+    {
+      *dst++ = *src;
+      src += stridePixels;
+    }
+  }
+
+  delete[] pixels;
+  pixels = dest;
+  std::swap(width, height);
+  stridePixels = width;
+  return true;
+}
+
+bool CPicture::TransposeOffAxis(uint32_t*& pixels,
+                                unsigned int& width,
+                                unsigned int& height,
+                                unsigned int& stridePixels)
+{
+  uint32_t *dest = new uint32_t[width * height * 4];
+  if (!dest)
+    return false;
+
+  unsigned int d_height = width, d_width = height;
+  for (unsigned int y = 0; y < d_height; y++)
+  {
+    const uint32_t* src = pixels + stridePixels * (d_width - 1) +
+                          (d_height - 1 - y); // y-th col from right, starting at bottom
+    uint32_t *dst = dest + d_width * y;                                        // y-th row, starting at left
+    for (unsigned int x = 0; x < d_width; x++)
+    {
+      *dst++ = *src;
+      src -= stridePixels;
+    }
+  }
+
+  delete[] pixels;
+  pixels = dest;
+  std::swap(width, height);
+  stridePixels = width;
+  return true;
+}