ImageDecoder.h

/*
 *  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.
 */
 
#pragma once
 
#include "../AddonBase.h"
#include "../c-api/addon-instance/imagedecoder.h"
 
#ifdef __cplusplus
 
#include <stdexcept>
 
namespace kodi
{
namespace addon
{
 
//##############################################################################
 
//==============================================================================
class ATTR_DLL_LOCAL ImageDecoderInfoTag
{
public:
  ImageDecoderInfoTag() = default;
 
 
  void SetWidth(int width) { m_width = width; }
 
  int GetWidth() const { return m_width; }
 
  void SetHeight(int height) { m_height = height; }
 
  int GetHeight() const { return m_height; }
 
  void SetDistance(int distance) { m_distance = distance; }
 
  int GetDistance() const { return m_distance; }
 
  void SetColor(ADDON_IMG_COLOR color) { m_color = color; }
 
  ADDON_IMG_COLOR GetColor() const { return m_color; }
 
  void SetMeteringMode(ADDON_IMG_METERING_MODE metering_mode) { m_metering_mode = metering_mode; }
 
  ADDON_IMG_METERING_MODE GetMeteringMode() const { return m_metering_mode; }
 
  void SetExposureTime(float exposure_time) { m_exposure_time = exposure_time; }
 
  float GetExposureTime() const { return m_exposure_time; }
 
  void SetExposureBias(float exposure_bias) { m_exposure_bias = exposure_bias; }
 
  float GetExposureBias() const { return m_exposure_bias; }
 
  void SetExposureProgram(ADDON_IMG_EXPOSURE_PROGRAM exposure_program)
  {
    m_exposure_program = exposure_program;
  }
 
  ADDON_IMG_EXPOSURE_PROGRAM GetExposureProgram() const { return m_exposure_program; }
 
  void SetExposureMode(ADDON_IMG_EXPOSURE_MODE exposure_mode) { m_exposure_mode = exposure_mode; }
 
  ADDON_IMG_EXPOSURE_MODE GetExposureMode() const { return m_exposure_mode; }
 
  void SetOrientation(ADDON_IMG_ORIENTATION orientation) { m_orientation = orientation; }
 
  ADDON_IMG_ORIENTATION GetOrientation() const { return m_orientation; }
 
  void SetTimeCreated(time_t time_created) { m_time_created = time_created; }
 
  time_t GetTimeCreated() const { return m_time_created; }
 
  void SetApertureFNumber(float aperture_f_number) { m_aperture_f_number = aperture_f_number; }
 
  float GetApertureFNumber() const { return m_aperture_f_number; }
 
  void SetFlashUsed(ADDON_IMG_FLASH_TYPE flash_used) { m_flash_used = flash_used; }
 
  ADDON_IMG_FLASH_TYPE GetFlashUsed() const { return m_flash_used; }
 
  void SetFocalLength(int focal_length) { m_focal_length = focal_length; }
 
  int GetFocalLength() const { return m_focal_length; }
 
  void SetLightSource(ADDON_IMG_LIGHT_SOURCE light_source) { m_light_source = light_source; }
 
  ADDON_IMG_LIGHT_SOURCE GetLightSource() const { return m_light_source; }
 
  void SetFocalLengthIn35mmFormat(int focal_length_in_35mm_format)
  {
    m_focal_length_in_35mm_format = focal_length_in_35mm_format;
  }
 
  int GetFocalLengthIn35mmFormat() const { return m_focal_length_in_35mm_format; }
 
  void SetDigitalZoomRatio(float digital_zoom_ratio) { m_digital_zoom_ratio = digital_zoom_ratio; }
 
  float GetDigitalZoomRatio() const { return m_digital_zoom_ratio; }
 
  void SetISOSpeed(float iso_speed) { m_iso_speed = iso_speed; }
 
  float GetISOSpeed() const { return m_iso_speed; }
 
  void SetGPSInfo(bool gps_info_present,
                  char latitude_ref,
                  float latitude[3],
                  char longitude_ref,
                  float longitude[3],
                  int altitude_ref,
                  float altitude)
  {
    if (!latitude || !longitude)
      return;
 
    m_gps_info_present = gps_info_present;
    if (gps_info_present)
    {
      m_latitude_ref = latitude_ref;
      m_longitude_ref = longitude_ref;
      for (int i = 0; i < 3; i++)
      {
        m_latitude[i] = latitude[i];
        m_longitude[i] = longitude[i];
      }
      m_altitude_ref = altitude_ref;
      m_altitude = altitude;
    }
    else
    {
      m_latitude_ref = 0.0f;
      m_longitude_ref = 0.0f;
      for (int i = 0; i < 3; i++)
        latitude[i] = longitude[i] = 0.0f;
      m_altitude_ref = 0;
      m_altitude = 0.0f;
    }
  }
 
  void GetGPSInfo(bool& gps_info_present,
                  char& latitude_ref,
                  float latitude[3],
                  char& longitude_ref,
                  float longitude[3],
                  int& altitude_ref,
                  float& altitude)
  {
    if (!latitude || !longitude)
      return;
 
    gps_info_present = m_gps_info_present;
    if (m_gps_info_present)
    {
      latitude_ref = m_latitude_ref;
      longitude_ref = m_longitude_ref;
      for (int i = 0; i < 3; i++)
      {
        latitude[i] = m_latitude[i];
        longitude[i] = m_longitude[i];
      }
      altitude_ref = m_altitude_ref;
      altitude = m_altitude;
    }
    else
    {
      latitude_ref = ' ';
      longitude_ref = ' ';
      for (int i = 0; i < 3; i++)
        latitude[i] = longitude[i] = 0.0f;
      altitude_ref = 0;
      altitude = 0.0f;
    }
  }
 
  void SetCameraManufacturer(const std::string& camera_manufacturer)
  {
    m_camera_manufacturer = camera_manufacturer;
  }
 
  const std::string& GetCameraManufacturer() const { return m_camera_manufacturer; }
 
  void SetCameraModel(const std::string& camera_model) { m_camera_model = camera_model; }
 
  const std::string& GetCameraModel() const { return m_camera_model; }
 
  void SetAuthor(const std::string& author) { m_author = author; }
 
  const std::string& GetAuthor() const { return m_author; }
 
  void SetDescription(const std::string& description) { m_description = description; }
 
  const std::string& GetDescription() const { return m_description; }
 
  void SetCopyright(const std::string& copyright) { m_copyright = copyright; }
 
  const std::string& GetCopyright() const { return m_copyright; }
 
 
private:
  int m_width{};
  int m_height{};
  float m_distance{};
  ADDON_IMG_ORIENTATION m_orientation{ADDON_IMG_ORIENTATION_NONE};
  ADDON_IMG_COLOR m_color{ADDON_IMG_COLOR_COLORED};
  ADDON_IMG_METERING_MODE m_metering_mode{ADDON_IMG_METERING_MODE_UNKNOWN};
  float m_exposure_time{};
  float m_exposure_bias{};
  ADDON_IMG_EXPOSURE_PROGRAM m_exposure_program{ADDON_IMG_EXPOSURE_PROGRAM_UNDEFINED};
  ADDON_IMG_EXPOSURE_MODE m_exposure_mode{ADDON_IMG_EXPOSURE_MODE_AUTO};
  time_t m_time_created{};
  float m_aperture_f_number{};
  ADDON_IMG_FLASH_TYPE m_flash_used{ADDON_IMG_FLASH_TYPE_NO_FLASH};
  ADDON_IMG_LIGHT_SOURCE m_light_source{};
  int m_focal_length{};
  int m_focal_length_in_35mm_format{};
  float m_digital_zoom_ratio{};
  float m_iso_speed{};
 
  bool m_gps_info_present{false};
  char m_latitude_ref{' '};
  float m_latitude[3]{}; /* Deg,min,sec */
  char m_longitude_ref{' '};
  float m_longitude[3]{}; /* Deg,min,sec */
  int m_altitude_ref{};
  float m_altitude{};
 
  std::string m_camera_manufacturer;
  std::string m_camera_model;
  std::string m_author;
  std::string m_description;
  std::string m_copyright;
};
//------------------------------------------------------------------------------
 
//==============================================================================
//------------------------------------------------------------------------------
class ATTR_DLL_LOCAL CInstanceImageDecoder : public IAddonInstance
{
public:
  //============================================================================
  explicit CInstanceImageDecoder(const IInstanceInfo& instance) : IAddonInstance(instance)
  {
    if (CPrivateBase::m_interface->globalSingleInstance != nullptr)
      throw std::logic_error("kodi::addon::CInstanceImageDecoder: Creation of multiple together "
                             "with single instance way is not allowed!");
 
    SetAddonStruct(instance);
  }
  //----------------------------------------------------------------------------
 
  ~CInstanceImageDecoder() override = default;
 
  //==========================================================================
  virtual bool SupportsFile(const std::string& filename) { return true; }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  virtual bool ReadTag(const std::string& file, kodi::addon::ImageDecoderInfoTag& tag)
  {
    return false;
  }
  //--------------------------------------------------------------------------
 
  //============================================================================
  virtual bool LoadImageFromMemory(const std::string& mimetype,
                                   const uint8_t* buffer,
                                   size_t bufSize,
                                   unsigned int& width,
                                   unsigned int& height) = 0;
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool Decode(uint8_t* pixels,
                      unsigned int width,
                      unsigned int height,
                      unsigned int pitch,
                      ADDON_IMG_FMT format) = 0;
  //----------------------------------------------------------------------------
 
private:
  void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance)
  {
    instance->hdl = this;
    instance->imagedecoder->toAddon->supports_file = ADDON_supports_file;
    instance->imagedecoder->toAddon->read_tag = ADDON_read_tag;
    instance->imagedecoder->toAddon->load_image_from_memory = ADDON_load_image_from_memory;
    instance->imagedecoder->toAddon->decode = ADDON_decode;
  }
 
  inline static bool ADDON_supports_file(const KODI_ADDON_IMAGEDECODER_HDL hdl, const char* file)
  {
    return static_cast<CInstanceImageDecoder*>(hdl)->SupportsFile(file);
  }
 
  inline static bool ADDON_read_tag(const KODI_ADDON_IMAGEDECODER_HDL hdl,
                                    const char* file,
                                    struct KODI_ADDON_IMAGEDECODER_INFO_TAG* tag)
  {
#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable : 4996)
#endif // _WIN32
    kodi::addon::ImageDecoderInfoTag cppTag;
    bool ret = static_cast<CInstanceImageDecoder*>(hdl)->ReadTag(file, cppTag);
    if (ret)
    {
      tag->width = cppTag.GetWidth();
      tag->height = cppTag.GetHeight();
      tag->distance = cppTag.GetDistance();
      tag->color = cppTag.GetColor();
      tag->orientation = cppTag.GetOrientation();
      tag->metering_mode = cppTag.GetMeteringMode();
      tag->exposure_time = cppTag.GetExposureTime();
      tag->exposure_bias = cppTag.GetExposureBias();
      tag->exposure_mode = cppTag.GetExposureMode();
      tag->exposure_program = cppTag.GetExposureProgram();
      tag->time_created = cppTag.GetTimeCreated();
      tag->aperture_f_number = cppTag.GetApertureFNumber();
      tag->flash_used = cppTag.GetFlashUsed();
      tag->light_source = cppTag.GetLightSource();
      tag->focal_length = cppTag.GetFocalLength();
      tag->focal_length_in_35mm_format = cppTag.GetFocalLengthIn35mmFormat();
      tag->iso_speed = cppTag.GetISOSpeed();
      tag->digital_zoom_ratio = cppTag.GetDigitalZoomRatio();
      cppTag.GetGPSInfo(tag->gps_info_present, tag->latitude_ref, tag->latitude, tag->longitude_ref,
                        tag->longitude, tag->altitude_ref, tag->altitude);
      tag->camera_manufacturer = strdup(cppTag.GetCameraManufacturer().c_str());
      tag->camera_model = strdup(cppTag.GetCameraModel().c_str());
      tag->author = strdup(cppTag.GetAuthor().c_str());
      tag->description = strdup(cppTag.GetDescription().c_str());
      tag->copyright = strdup(cppTag.GetCopyright().c_str());
    }
    return ret;
#ifdef _WIN32
#pragma warning(pop)
#endif // _WIN32
  }
 
  inline static bool ADDON_load_image_from_memory(const KODI_ADDON_IMAGEDECODER_HDL hdl,
                                                  const char* mimetype,
                                                  const uint8_t* buffer,
                                                  size_t bufSize,
                                                  unsigned int* width,
                                                  unsigned int* height)
  {
    return static_cast<CInstanceImageDecoder*>(hdl)->LoadImageFromMemory(mimetype, buffer, bufSize,
                                                                         *width, *height);
  }
 
  inline static bool ADDON_decode(const KODI_ADDON_IMAGEDECODER_HDL hdl,
                                  uint8_t* pixels,
                                  size_t pixels_size,
                                  unsigned int width,
                                  unsigned int height,
                                  unsigned int pitch,
                                  enum ADDON_IMG_FMT format)
  {
    return static_cast<CInstanceImageDecoder*>(hdl)->Decode(pixels, width, height, pitch, format);
  }
};
 
} /* namespace addon */
} /* namespace kodi */
#endif /* __cplusplus */