dali/devel-api/adaptor-framework/image-loading.cpp

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 // CLASS HEADER
  18 #include <dali/devel-api/adaptor-framework/image-loading.h>
  19
  20 // INTERNAL INCLUDES
  21 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
  22 #include <dali/internal/imaging/common/file-download.h>
  23 #include <dali/internal/imaging/common/image-loader.h>
  24 #include <dali/internal/system/common/file-reader.h>
  25 #include <dali/public-api/object/property-map.h>
  26
  27 namespace Dali
  28 {
  29 namespace
  30 {
  31 // limit maximum image down load size to 50 MB
  32 const size_t MAXIMUM_DOWNLOAD_IMAGE_SIZE = 50 * 1024 * 1024;
  33
  34 } // namespace
  35
  36 Devel::PixelBuffer LoadImageFromFile(const std::string& url, ImageDimensions size, FittingMode::Type fittingMode, SamplingMode::Type samplingMode, bool orientationCorrection)
  37 {
  38   Integration::BitmapResourceType resourceType(size, fittingMode, samplingMode, orientationCorrection);
  39
  40   Internal::Platform::FileReader fileReader(url);
  41   FILE* const                    fp = fileReader.GetFile();
  42   if(fp != NULL)
  43   {
  44     Dali::Devel::PixelBuffer bitmap;
  45     bool                     success = TizenPlatform::ImageLoader::ConvertStreamToBitmap(resourceType, url, fp, bitmap);
  46     if(success && bitmap)
  47     {
  48       return bitmap;
  49     }
  50   }
  51   return Dali::Devel::PixelBuffer();
  52 }
  53
  54 Devel::PixelBuffer LoadImageFromBuffer(const Dali::Vector<uint8_t>& buffer, ImageDimensions size, FittingMode::Type fittingMode, SamplingMode::Type samplingMode, bool orientationCorrection)
  55 {
  56   if(buffer.Empty())
  57   {
  58     DALI_LOG_ERROR("buffer is empty!\n");
  59     return Dali::Devel::PixelBuffer();
  60   }
  61   Integration::BitmapResourceType resourceType(size, fittingMode, samplingMode, orientationCorrection);
  62
  63   Internal::Platform::FileReader fileReader(buffer);
  64   FILE* const                    fp = fileReader.GetFile();
  65   if(fp != NULL)
  66   {
  67     Dali::Devel::PixelBuffer bitmap;
  68     // Make path as empty string. Path information just for file format hint.
  69     bool                     success = TizenPlatform::ImageLoader::ConvertStreamToBitmap(resourceType, std::string(""), fp, bitmap);
  70     if(success && bitmap)
  71     {
  72       return bitmap;
  73     }
  74   }
  75   return Dali::Devel::PixelBuffer();
  76 }
  77
  78 ImageDimensions GetClosestImageSize(const std::string& filename,
  79                                     ImageDimensions    size,
  80                                     FittingMode::Type  fittingMode,
  81                                     SamplingMode::Type samplingMode,
  82                                     bool               orientationCorrection)
  83 {
  84   ImageDimensions dimension = TizenPlatform::ImageLoader::GetClosestImageSize(filename, size, fittingMode, samplingMode, orientationCorrection);
  85
  86   dimension.SetWidth(std::min(dimension.GetWidth(), static_cast<uint16_t>(GetMaxTextureSize())));
  87   dimension.SetHeight(std::min(dimension.GetHeight(), static_cast<uint16_t>(GetMaxTextureSize())));
  88
  89   return dimension;
  90 }
  91
  92 ImageDimensions GetOriginalImageSize(const std::string& filename, bool orientationCorrection)
  93 {
  94   return TizenPlatform::ImageLoader::GetClosestImageSize(filename, ImageDimensions(0, 0), FittingMode::DEFAULT, SamplingMode::BOX_THEN_LINEAR, orientationCorrection);
  95 }
  96
  97 Devel::PixelBuffer DownloadImageSynchronously(const std::string& url, ImageDimensions size, FittingMode::Type fittingMode, SamplingMode::Type samplingMode, bool orientationCorrection)
  98 {
  99   Integration::BitmapResourceType resourceType(size, fittingMode, samplingMode, orientationCorrection);
 100
 101   bool                  succeeded;
 102   Dali::Vector<uint8_t> dataBuffer;
 103   size_t                dataSize;
 104
 105   succeeded = TizenPlatform::Network::DownloadRemoteFileIntoMemory(url, dataBuffer, dataSize, MAXIMUM_DOWNLOAD_IMAGE_SIZE);
 106   if(succeeded)
 107   {
 108     size_t blobSize = dataBuffer.Size();
 109
 110     DALI_ASSERT_DEBUG(blobSize > 0U);
 111
 112     if(blobSize > 0U)
 113     {
 114       // Open a file handle on the memory buffer:
 115       Dali::Internal::Platform::FileReader fileReader(dataBuffer, blobSize);
 116       FILE* const                          fp = fileReader.GetFile();
 117       if(NULL != fp)
 118       {
 119         Dali::Devel::PixelBuffer bitmap;
 120         bool                     result = TizenPlatform::ImageLoader::ConvertStreamToBitmap(
 121           resourceType,
 122           url,
 123           fp,
 124           bitmap);
 125
 126         if(result && bitmap)
 127         {
 128           return bitmap;
 129         }
 130         else
 131         {
 132           DALI_LOG_WARNING("Unable to decode bitmap supplied as in-memory blob.\n");
 133         }
 134       }
 135     }
 136   }
 137   return Dali::Devel::PixelBuffer();
 138 }
 139
 140 unsigned int GetMaxTextureSize()
 141 {
 142   return TizenPlatform::ImageLoader::GetMaxTextureSize();
 143 }
 144
 145 } // namespace Dali