xbmc/filesystem/XbtFile.cpp

   1 /*
   2  *  Copyright (C) 2015-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 "XbtFile.h"
  10
  11 #include "URL.h"
  12 #include "filesystem/File.h"
  13 #include "filesystem/XbtManager.h"
  14 #include "guilib/TextureBundleXBT.h"
  15 #include "guilib/TextureFormats.h"
  16 #include "guilib/XBTFReader.h"
  17 #include "utils/StringUtils.h"
  18
  19 #include <algorithm>
  20 #include <climits>
  21 #include <cstring>
  22 #include <memory>
  23 #include <string>
  24 #include <utility>
  25
  26 namespace XFILE
  27 {
  28
  29 CXbtFile::CXbtFile()
  30   : m_url(),
  31     m_xbtfReader(nullptr),
  32     m_xbtfFile(),
  33     m_frameStartPositions(),
  34     m_unpackedFrames()
  35 { }
  36
  37 CXbtFile::~CXbtFile()
  38 {
  39   Close();
  40 }
  41
  42 bool CXbtFile::Open(const CURL& url)
  43 {
  44   if (m_open)
  45     return false;
  46
  47   CURL xbtUrl(url);
  48   xbtUrl.SetOptions("");
  49
  50   if (!GetReaderAndFile(url, m_xbtfReader, m_xbtfFile))
  51     return false;
  52
  53   m_url = url;
  54   m_open = true;
  55
  56   uint64_t frameStartPosition = 0;
  57   const auto& frames = m_xbtfFile.GetFrames();
  58   for (const auto& frame : frames)
  59   {
  60     m_frameStartPositions.push_back(frameStartPosition);
  61
  62     frameStartPosition += frame.GetUnpackedSize();
  63   }
  64
  65   m_frameIndex = 0;
  66   m_positionWithinFrame = 0;
  67   m_positionTotal = 0;
  68
  69   m_unpackedFrames.resize(frames.size());
  70
  71   return true;
  72 }
  73
  74 void CXbtFile::Close()
  75 {
  76   m_unpackedFrames.clear();
  77   m_frameIndex = 0;
  78   m_positionWithinFrame = 0;
  79   m_positionTotal = 0;
  80   m_frameStartPositions.clear();
  81   m_open = false;
  82 }
  83
  84 bool CXbtFile::Exists(const CURL& url)
  85 {
  86   CXBTFFile dummy;
  87   return GetFile(url, dummy);
  88 }
  89
  90 int64_t CXbtFile::GetPosition()
  91 {
  92   if (!m_open)
  93     return -1;
  94
  95   return m_positionTotal;
  96 }
  97
  98 int64_t CXbtFile::GetLength()
  99 {
 100   if (!m_open)
 101     return -1;
 102
 103   return static_cast<int>(m_xbtfFile.GetUnpackedSize());
 104 }
 105
 106 int CXbtFile::Stat(struct __stat64 *buffer)
 107 {
 108   if (!m_open)
 109     return -1;
 110
 111   return Stat(m_url, buffer);
 112 }
 113
 114 int CXbtFile::Stat(const CURL& url, struct __stat64* buffer)
 115 {
 116   if (!buffer)
 117     return -1;
 118
 119   *buffer = {};
 120
 121   // check if the file exists
 122   CXBTFReaderPtr reader;
 123   CXBTFFile file;
 124   if (!GetReaderAndFile(url, reader, file))
 125   {
 126     // check if the URL points to the XBT file itself
 127     if (!url.GetFileName().empty() || !CFile::Exists(url.GetHostName()))
 128       return -1;
 129
 130     // stat the XBT file itself
 131     if (XFILE::CFile::Stat(url.GetHostName(), buffer) != 0)
 132       return -1;
 133
 134     buffer->st_mode = _S_IFDIR;
 135     return 0;
 136   }
 137
 138   // stat the XBT file itself
 139   if (XFILE::CFile::Stat(url.GetHostName(), buffer) != 0)
 140     return -1;
 141
 142   buffer->st_size = file.GetUnpackedSize();
 143
 144   return 0;
 145 }
 146
 147 ssize_t CXbtFile::Read(void* lpBuf, size_t uiBufSize)
 148 {
 149   if (lpBuf == nullptr || !m_open)
 150     return -1;
 151
 152   // nothing to read
 153   if (m_xbtfFile.GetFrames().empty() || m_positionTotal >= GetLength())
 154     return 0;
 155
 156   // we can't read more than is left
 157   if (static_cast<int64_t>(uiBufSize) > GetLength() - m_positionTotal)
 158     uiBufSize = static_cast<ssize_t>(GetLength() - m_positionTotal);
 159
 160   // we can't read more than we can signal with the return value
 161   if (uiBufSize > SSIZE_MAX)
 162     uiBufSize = SSIZE_MAX;
 163
 164   const auto& frames = m_xbtfFile.GetFrames();
 165
 166   size_t remaining = uiBufSize;
 167   while (remaining > 0)
 168   {
 169     const CXBTFFrame& frame = frames[m_frameIndex];
 170
 171     // check if we have already unpacked the current frame
 172     if (m_unpackedFrames[m_frameIndex].empty())
 173     {
 174       // unpack the data from the current frame
 175       std::vector<uint8_t> unpackedFrame =
 176           CTextureBundleXBT::UnpackFrame(*m_xbtfReader.get(), frame);
 177       if (unpackedFrame.empty())
 178       {
 179         Close();
 180         return -1;
 181       }
 182
 183       m_unpackedFrames[m_frameIndex] = std::move(unpackedFrame);
 184     }
 185
 186     // determine how many bytes we need to copy from the current frame
 187     uint64_t remainingBytesInFrame = frame.GetUnpackedSize() - m_positionWithinFrame;
 188     size_t bytesToCopy = remaining;
 189     if (remainingBytesInFrame <= SIZE_MAX)
 190       bytesToCopy = std::min(remaining, static_cast<size_t>(remainingBytesInFrame));
 191
 192     // copy the data
 193     memcpy(lpBuf, m_unpackedFrames[m_frameIndex].data() + m_positionWithinFrame, bytesToCopy);
 194     m_positionWithinFrame += bytesToCopy;
 195     m_positionTotal += bytesToCopy;
 196     remaining -= bytesToCopy;
 197
 198     // check if we need to go to the next frame and there is a next frame
 199     if (m_positionWithinFrame >= frame.GetUnpackedSize() && m_frameIndex < frames.size() - 1)
 200     {
 201       m_positionWithinFrame = 0;
 202       m_frameIndex += 1;
 203     }
 204   }
 205
 206   return uiBufSize;
 207 }
 208
 209 int64_t CXbtFile::Seek(int64_t iFilePosition, int iWhence)
 210 {
 211   if (!m_open)
 212     return -1;
 213
 214   int64_t newPosition = m_positionTotal;
 215   switch (iWhence)
 216   {
 217     case SEEK_SET:
 218       newPosition = iFilePosition;
 219       break;
 220
 221     case SEEK_CUR:
 222       newPosition += iFilePosition;
 223       break;
 224
 225     case SEEK_END:
 226       newPosition = GetLength() + iFilePosition;
 227       break;
 228
 229     // unsupported seek mode
 230     default:
 231       return -1;
 232   }
 233
 234   // can't seek before the beginning or after the end of the file
 235   if (newPosition < 0 || newPosition >= GetLength())
 236     return -1;
 237
 238   // seeking backwards doesn't require additional work
 239   if (newPosition <= m_positionTotal)
 240   {
 241     m_positionTotal = newPosition;
 242     return m_positionTotal;
 243   }
 244
 245   // when seeking forward we need to unpack all frames we seek past
 246   const auto& frames = m_xbtfFile.GetFrames();
 247   while (m_positionTotal < newPosition)
 248   {
 249     const CXBTFFrame& frame = frames[m_frameIndex];
 250
 251     // check if we have already unpacked the current frame
 252     if (m_unpackedFrames[m_frameIndex].empty())
 253     {
 254       // unpack the data from the current frame
 255       std::vector<uint8_t> unpackedFrame =
 256           CTextureBundleXBT::UnpackFrame(*m_xbtfReader.get(), frame);
 257       if (unpackedFrame.empty())
 258       {
 259         Close();
 260         return -1;
 261       }
 262
 263       m_unpackedFrames[m_frameIndex] = std::move(unpackedFrame);
 264     }
 265
 266     int64_t remainingBytesToSeek = newPosition - m_positionTotal;
 267     // check if the new position is within the current frame
 268     uint64_t remainingBytesInFrame = frame.GetUnpackedSize() - m_positionWithinFrame;
 269     if (static_cast<uint64_t>(remainingBytesToSeek) < remainingBytesInFrame)
 270     {
 271       m_positionWithinFrame += remainingBytesToSeek;
 272       break;
 273     }
 274
 275     // otherwise move to the end of the frame
 276     m_positionTotal += remainingBytesInFrame;
 277     m_positionWithinFrame += remainingBytesInFrame;
 278
 279     // and go to the next frame if there is a next frame
 280     if (m_frameIndex < frames.size() - 1)
 281     {
 282       m_positionWithinFrame = 0;
 283       m_frameIndex += 1;
 284     }
 285   }
 286
 287   m_positionTotal = newPosition;
 288   return m_positionTotal;
 289 }
 290
 291 uint32_t CXbtFile::GetImageWidth() const
 292 {
 293   CXBTFFrame frame;
 294   if (!GetFirstFrame(frame))
 295     return false;
 296
 297   return frame.GetWidth();
 298 }
 299
 300 uint32_t CXbtFile::GetImageHeight() const
 301 {
 302   CXBTFFrame frame;
 303   if (!GetFirstFrame(frame))
 304     return false;
 305
 306   return frame.GetHeight();
 307 }
 308
 309 XB_FMT CXbtFile::GetImageFormat() const
 310 {
 311   CXBTFFrame frame;
 312   if (!GetFirstFrame(frame))
 313     return XB_FMT_UNKNOWN;
 314
 315   return frame.GetFormat();
 316 }
 317
 318 KD_TEX_FMT CXbtFile::GetKDFormat() const
 319 {
 320   CXBTFFrame frame;
 321   if (!GetFirstFrame(frame))
 322     return KD_TEX_FMT_UNKNOWN;
 323
 324   return frame.GetKDFormat();
 325 }
 326
 327 KD_TEX_FMT CXbtFile::GetKDFormatType() const
 328 {
 329   CXBTFFrame frame;
 330   if (!GetFirstFrame(frame))
 331     return KD_TEX_FMT_UNKNOWN;
 332
 333   return frame.GetKDFormatType();
 334 }
 335
 336 KD_TEX_ALPHA CXbtFile::GetKDAlpha() const
 337 {
 338   CXBTFFrame frame;
 339   if (!GetFirstFrame(frame))
 340     return KD_TEX_ALPHA_OPAQUE;
 341
 342   return frame.GetKDAlpha();
 343 }
 344
 345 KD_TEX_SWIZ CXbtFile::GetKDSwizzle() const
 346 {
 347   CXBTFFrame frame;
 348   if (!GetFirstFrame(frame))
 349     return KD_TEX_SWIZ_RGBA;
 350
 351   return frame.GetKDSwizzle();
 352 }
 353
 354 bool CXbtFile::HasImageAlpha() const
 355 {
 356   CXBTFFrame frame;
 357   if (!GetFirstFrame(frame))
 358     return false;
 359
 360   return frame.HasAlpha();
 361 }
 362
 363 bool CXbtFile::GetFirstFrame(CXBTFFrame& frame) const
 364 {
 365   if (!m_open)
 366     return false;
 367
 368   const auto& frames = m_xbtfFile.GetFrames();
 369   if (frames.empty())
 370     return false;
 371
 372   frame = frames.at(0);
 373   return true;
 374 }
 375
 376 bool CXbtFile::GetReader(const CURL& url, CXBTFReaderPtr& reader)
 377 {
 378   CURL xbtUrl(url);
 379   xbtUrl.SetOptions("");
 380
 381   return CXbtManager::GetInstance().GetReader(xbtUrl, reader);
 382 }
 383
 384 bool CXbtFile::GetReaderAndFile(const CURL& url, CXBTFReaderPtr& reader, CXBTFFile& file)
 385 {
 386   if (!GetReader(url, reader))
 387     return false;
 388
 389   CURL xbtUrl(url);
 390   xbtUrl.SetOptions("");
 391
 392   // CXBTFReader stores all filenames in lower case
 393   std::string fileName = xbtUrl.GetFileName();
 394   StringUtils::ToLower(fileName);
 395
 396   return reader->Get(fileName, file);
 397 }
 398
 399 bool CXbtFile::GetFile(const CURL& url, CXBTFFile& file)
 400 {
 401   CXBTFReaderPtr reader;
 402   return GetReaderAndFile(url, reader, file);
 403 }
 404
 405 }