xbmc/guilib/XBTF.cpp

   1 /*
   2  *  Copyright (C) 2005-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 #include "XBTF.h"
  10
  11 #include <cstring>
  12 #include <utility>
  13
  14 CXBTFFrame::CXBTFFrame()
  15 {
  16   m_width = 0;
  17   m_height = 0;
  18   m_packedSize = 0;
  19   m_unpackedSize = 0;
  20   m_offset = 0;
  21   m_format = XB_FMT_UNKNOWN;
  22   m_duration = 0;
  23 }
  24
  25 uint32_t CXBTFFrame::GetWidth() const
  26 {
  27   return m_width;
  28 }
  29
  30 void CXBTFFrame::SetWidth(uint32_t width)
  31 {
  32   m_width = width;
  33 }
  34
  35 uint32_t CXBTFFrame::GetHeight() const
  36 {
  37   return m_height;
  38 }
  39
  40 void CXBTFFrame::SetHeight(uint32_t height)
  41 {
  42   m_height = height;
  43 }
  44
  45 uint64_t CXBTFFrame::GetPackedSize() const
  46 {
  47   return m_packedSize;
  48 }
  49
  50 void CXBTFFrame::SetPackedSize(uint64_t size)
  51 {
  52   m_packedSize = size;
  53 }
  54
  55 bool CXBTFFrame::IsPacked() const
  56 {
  57   return m_unpackedSize != m_packedSize;
  58 }
  59
  60 bool CXBTFFrame::HasAlpha() const
  61 {
  62   return (m_format & XB_FMT_OPAQUE) == 0;
  63 }
  64
  65 uint64_t CXBTFFrame::GetUnpackedSize() const
  66 {
  67   return m_unpackedSize;
  68 }
  69
  70 void CXBTFFrame::SetUnpackedSize(uint64_t size)
  71 {
  72   m_unpackedSize = size;
  73 }
  74
  75 void CXBTFFrame::SetFormat(XB_FMT format)
  76 {
  77   m_format = format;
  78 }
  79
  80 XB_FMT CXBTFFrame::GetFormat(bool raw) const
  81 {
  82   return raw ? m_format : static_cast<XB_FMT>(m_format & XB_FMT_MASK);
  83 }
  84
  85 uint64_t CXBTFFrame::GetOffset() const
  86 {
  87   return m_offset;
  88 }
  89
  90 void CXBTFFrame::SetOffset(uint64_t offset)
  91 {
  92   m_offset = offset;
  93 }
  94
  95 uint32_t CXBTFFrame::GetDuration() const
  96 {
  97   return m_duration;
  98 }
  99
 100 void CXBTFFrame::SetDuration(uint32_t duration)
 101 {
 102   m_duration = duration;
 103 }
 104
 105 uint64_t CXBTFFrame::GetHeaderSize() const
 106 {
 107   uint64_t result =
 108     sizeof(m_width) +
 109     sizeof(m_height) +
 110     sizeof(m_format) +
 111     sizeof(m_packedSize) +
 112     sizeof(m_unpackedSize) +
 113     sizeof(m_offset) +
 114     sizeof(m_duration);
 115
 116   return result;
 117 }
 118
 119 CXBTFFile::CXBTFFile()
 120   : m_path(),
 121     m_frames()
 122 { }
 123
 124 const std::string& CXBTFFile::GetPath() const
 125 {
 126   return m_path;
 127 }
 128
 129 void CXBTFFile::SetPath(const std::string& path)
 130 {
 131   m_path = path;
 132 }
 133
 134 uint32_t CXBTFFile::GetLoop() const
 135 {
 136   return m_loop;
 137 }
 138
 139 void CXBTFFile::SetLoop(uint32_t loop)
 140 {
 141   m_loop = loop;
 142 }
 143
 144 const std::vector<CXBTFFrame>& CXBTFFile::GetFrames() const
 145 {
 146   return m_frames;
 147 }
 148
 149 std::vector<CXBTFFrame>& CXBTFFile::GetFrames()
 150 {
 151   return m_frames;
 152 }
 153
 154 uint64_t CXBTFFile::GetPackedSize() const
 155 {
 156   uint64_t size = 0;
 157   for (const auto& frame : m_frames)
 158     size += frame.GetPackedSize();
 159
 160   return size;
 161 }
 162
 163 uint64_t CXBTFFile::GetUnpackedSize() const
 164 {
 165   uint64_t size = 0;
 166   for (const auto& frame : m_frames)
 167     size += frame.GetUnpackedSize();
 168
 169   return size;
 170 }
 171
 172 uint64_t CXBTFFile::GetHeaderSize() const
 173 {
 174   uint64_t result =
 175     MaximumPathLength +
 176     sizeof(m_loop) +
 177     sizeof(uint32_t); /* Number of frames */
 178
 179   for (const auto& frame : m_frames)
 180     result += frame.GetHeaderSize();
 181
 182   return result;
 183 }
 184
 185 uint64_t CXBTFBase::GetHeaderSize() const
 186 {
 187   uint64_t result = XBTF_MAGIC.size() + XBTF_VERSION.size() +
 188     sizeof(uint32_t) /* number of files */;
 189
 190   for (const auto& file : m_files)
 191     result += file.second.GetHeaderSize();
 192
 193   return result;
 194 }
 195
 196 bool CXBTFBase::Exists(const std::string& name) const
 197 {
 198   CXBTFFile dummy;
 199   return Get(name, dummy);
 200 }
 201
 202 bool CXBTFBase::Get(const std::string& name, CXBTFFile& file) const
 203 {
 204   const auto& iter = m_files.find(name);
 205   if (iter == m_files.end())
 206     return false;
 207
 208   file = iter->second;
 209   return true;
 210 }
 211
 212 std::vector<CXBTFFile> CXBTFBase::GetFiles() const
 213 {
 214   std::vector<CXBTFFile> files;
 215   files.reserve(m_files.size());
 216
 217   for (const auto& file : m_files)
 218     files.push_back(file.second);
 219
 220   return files;
 221 }
 222
 223 void CXBTFBase::AddFile(const CXBTFFile& file)
 224 {
 225   m_files.insert(std::make_pair(file.GetPath(), file));
 226 }
 227
 228 void CXBTFBase::UpdateFile(const CXBTFFile& file)
 229 {
 230   auto&& it = m_files.find(file.GetPath());
 231   if (it == m_files.end())
 232     return;
 233
 234   it->second = file;
 235 }