Line data    Source code

       1             : /******************************************************************************
       2             :  *
       3             :  * Project:  OpenGIS Simple Features Reference Implementation
       4             :  * Purpose:  Virtual file system /vsipmtiles/ PMTiles
       5             :  * Author:   Even Rouault <even.rouault at spatialys.com>
       6             :  *
       7             :  ******************************************************************************
       8             :  * Copyright (c) 2023, Planet Labs
       9             :  *
      10             :  * SPDX-License-Identifier: MIT
      11             :  ****************************************************************************/
      12             : 
      13             : #include "cpl_vsi_virtual.h"
      14             : 
      15             : #include "vsipmtiles.h"
      16             : #include "ogr_pmtiles.h"
      17             : 
      18             : #include "cpl_json.h"
      19             : 
      20             : #include <set>
      21             : 
      22             : #define ENDS_WITH_CI(a, b)                                                     \
      23             :     (strlen(a) >= strlen(b) && EQUAL(a + strlen(a) - strlen(b), b))
      24             : 
      25             : constexpr const char *PMTILES_HEADER_JSON = "pmtiles_header.json";
      26             : constexpr const char *METADATA_JSON = "metadata.json";
      27             : 
      28             : /************************************************************************/
      29             : /*                   VSIPMTilesFilesystemHandler                        */
      30             : /************************************************************************/
      31             : 
      32             : class VSIPMTilesFilesystemHandler final : public VSIFilesystemHandler
      33             : {
      34             :   public:
      35        1741 :     VSIPMTilesFilesystemHandler() = default;
      36             : 
      37             :     VSIVirtualHandleUniquePtr Open(const char *pszFilename,
      38             :                                    const char *pszAccess, bool bSetError,
      39             :                                    CSLConstList papszOptions) override;
      40             :     int Stat(const char *pszFilename, VSIStatBufL *pStatBuf,
      41             :              int nFlags) override;
      42             :     char **ReadDirEx(const char *pszDirname, int nMaxFiles) override;
      43             : };
      44             : 
      45             : /************************************************************************/
      46             : /*                   VSIPMTilesGetTileExtension()                       */
      47             : /************************************************************************/
      48             : 
      49          36 : static const char *VSIPMTilesGetTileExtension(OGRPMTilesDataset *poDS)
      50             : {
      51          36 :     const auto &sHeader = poDS->GetHeader();
      52          36 :     switch (sHeader.tile_type)
      53             :     {
      54           0 :         case pmtiles::TILETYPE_PNG:
      55           0 :             return ".png";
      56           0 :         case pmtiles::TILETYPE_JPEG:
      57           0 :             return ".jpg";
      58           0 :         case pmtiles::TILETYPE_WEBP:
      59           0 :             return ".webp";
      60          36 :         case pmtiles::TILETYPE_MVT:
      61          36 :             return ".mvt";
      62             :     }
      63           0 :     if (sHeader.tile_compression == pmtiles::COMPRESSION_GZIP)
      64           0 :         return ".bin.gz";
      65           0 :     if (sHeader.tile_compression == pmtiles::COMPRESSION_ZSTD)
      66           0 :         return ".bin.zstd";
      67           0 :     return ".bin";
      68             : }
      69             : 
      70             : /************************************************************************/
      71             : /*                  VSIPMTilesGetPMTilesHeaderJson()                    */
      72             : /************************************************************************/
      73             : 
      74           4 : static std::string VSIPMTilesGetPMTilesHeaderJson(OGRPMTilesDataset *poDS)
      75             : {
      76           4 :     const auto &sHeader = poDS->GetHeader();
      77           8 :     CPLJSONDocument oDoc;
      78           8 :     CPLJSONObject oRoot;
      79           4 :     oRoot.Set("root_dir_offset", sHeader.root_dir_offset);
      80           4 :     oRoot.Set("json_metadata_offset", sHeader.json_metadata_offset);
      81           4 :     oRoot.Set("json_metadata_bytes", sHeader.json_metadata_bytes);
      82           4 :     oRoot.Set("leaf_dirs_offset", sHeader.leaf_dirs_offset);
      83           4 :     oRoot.Set("leaf_dirs_bytes", sHeader.leaf_dirs_bytes);
      84           4 :     oRoot.Set("tile_data_offset", sHeader.tile_data_offset);
      85           4 :     oRoot.Set("tile_data_bytes", sHeader.tile_data_bytes);
      86           4 :     oRoot.Set("addressed_tiles_count", sHeader.addressed_tiles_count);
      87           4 :     oRoot.Set("tile_entries_count", sHeader.tile_entries_count);
      88           4 :     oRoot.Set("tile_contents_count", sHeader.tile_contents_count);
      89           4 :     oRoot.Set("clustered", sHeader.clustered);
      90           4 :     oRoot.Set("internal_compression", sHeader.internal_compression);
      91           4 :     oRoot.Set("internal_compression_str",
      92           4 :               OGRPMTilesDataset::GetCompression(sHeader.internal_compression));
      93           4 :     oRoot.Set("tile_compression", sHeader.tile_compression);
      94           4 :     oRoot.Set("tile_compression_str",
      95           4 :               OGRPMTilesDataset::GetCompression(sHeader.tile_compression));
      96           4 :     oRoot.Set("tile_type", sHeader.tile_type);
      97           4 :     oRoot.Set("tile_type_str", OGRPMTilesDataset::GetTileType(sHeader));
      98           4 :     oRoot.Set("min_zoom", sHeader.min_zoom);
      99           4 :     oRoot.Set("max_zoom", sHeader.max_zoom);
     100           4 :     oRoot.Set("min_lon_e7", sHeader.min_lon_e7);
     101           4 :     oRoot.Set("min_lon_e7_float", sHeader.min_lon_e7 / 10e6);
     102           4 :     oRoot.Set("min_lat_e7", sHeader.min_lat_e7);
     103           4 :     oRoot.Set("min_lat_e7_float", sHeader.min_lat_e7 / 10e6);
     104           4 :     oRoot.Set("max_lon_e7", sHeader.max_lon_e7);
     105           4 :     oRoot.Set("max_lon_e7_float", sHeader.max_lon_e7 / 10e6);
     106           4 :     oRoot.Set("max_lat_e7", sHeader.max_lat_e7);
     107           4 :     oRoot.Set("max_lat_e7_float", sHeader.max_lat_e7 / 10e6);
     108           4 :     oRoot.Set("center_zoom", sHeader.center_zoom);
     109           4 :     oRoot.Set("center_lon_e7", sHeader.center_lon_e7);
     110           4 :     oRoot.Set("center_lat_e7", sHeader.center_lat_e7);
     111           4 :     oDoc.SetRoot(oRoot);
     112           8 :     return oDoc.SaveAsString();
     113             : }
     114             : 
     115             : /************************************************************************/
     116             : /*                           VSIPMTilesOpen()                           */
     117             : /************************************************************************/
     118             : 
     119             : static std::unique_ptr<OGRPMTilesDataset>
     120          58 : VSIPMTilesOpen(const char *pszFilename, std::string &osSubfilename,
     121             :                int &nComponents, int &nZ, int &nX, int &nY)
     122             : {
     123          58 :     if (!STARTS_WITH(pszFilename, "/vsipmtiles/"))
     124           0 :         return nullptr;
     125          58 :     pszFilename += strlen("/vsipmtiles/");
     126             : 
     127         116 :     std::string osFilename(pszFilename);
     128          58 :     if (!osFilename.empty() && osFilename.back() == '/')
     129           0 :         osFilename.pop_back();
     130          58 :     pszFilename = osFilename.c_str();
     131             : 
     132          58 :     nZ = nX = nY = -1;
     133          58 :     nComponents = 0;
     134         116 :     std::string osPmtilesFilename;
     135             : 
     136          58 :     const char *pszPmtilesExt = strstr(pszFilename, ".pmtiles");
     137          58 :     if (!pszPmtilesExt)
     138           1 :         return nullptr;
     139             : 
     140         114 :     CPLStringList aosTokens;
     141             :     do
     142             :     {
     143          57 :         if (pszPmtilesExt[strlen(".pmtiles")] == '/')
     144             :         {
     145          54 :             const char *pszSubFile = pszPmtilesExt + strlen(".pmtiles/");
     146          54 :             osPmtilesFilename.assign(pszFilename, pszSubFile - pszFilename - 1);
     147          54 :             osSubfilename = pszPmtilesExt + strlen(".pmtiles/");
     148         101 :             if (osSubfilename == METADATA_JSON ||
     149          47 :                 osSubfilename == PMTILES_HEADER_JSON)
     150             :             {
     151          11 :                 break;
     152             :             }
     153             :         }
     154             :         else
     155             :         {
     156           3 :             osPmtilesFilename = pszFilename;
     157           3 :             osSubfilename.clear();
     158           3 :             break;
     159             :         }
     160             : 
     161          43 :         aosTokens = CSLTokenizeString2(osSubfilename.c_str(), "/", 0);
     162          43 :         nComponents = aosTokens.size();
     163          43 :         if (nComponents >= 4)
     164           0 :             return nullptr;
     165             : 
     166          43 :         if (CPLGetValueType(aosTokens[0]) != CPL_VALUE_INTEGER)
     167           2 :             return nullptr;
     168          41 :         nZ = atoi(aosTokens[0]);
     169          41 :         if (nComponents == 1)
     170           3 :             break;
     171             : 
     172          38 :         if (CPLGetValueType(aosTokens[1]) != CPL_VALUE_INTEGER)
     173           1 :             return nullptr;
     174          37 :         nX = atoi(aosTokens[1]);
     175          37 :         if (nComponents == 2)
     176           4 :             break;
     177             : 
     178          33 :         break;
     179             :     } while (false);
     180             : 
     181         108 :     GDALOpenInfo oOpenInfo(osPmtilesFilename.c_str(), GA_ReadOnly);
     182         108 :     CPLStringList aosOptions;
     183          54 :     aosOptions.SetNameValue("DECOMPRESS_TILES", "NO");
     184          54 :     aosOptions.SetNameValue("ACCEPT_ANY_TILE_TYPE", "YES");
     185          54 :     oOpenInfo.papszOpenOptions = aosOptions.List();
     186         108 :     auto poDS = std::make_unique<OGRPMTilesDataset>();
     187             :     {
     188          54 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
     189          54 :         if (!poDS->Open(&oOpenInfo))
     190           4 :             return nullptr;
     191             :     }
     192             : 
     193          50 :     if (nComponents == 3)
     194             :     {
     195          33 :         const char *pszTileExt = VSIPMTilesGetTileExtension(poDS.get());
     196          33 :         if (!ENDS_WITH_CI(aosTokens[2], pszTileExt))
     197           2 :             return nullptr;
     198          31 :         aosTokens[2][strlen(aosTokens[2]) - strlen(pszTileExt)] = 0;
     199          31 :         if (CPLGetValueType(aosTokens[2]) != CPL_VALUE_INTEGER)
     200           0 :             return nullptr;
     201          31 :         nY = atoi(aosTokens[2]);
     202             :     }
     203          48 :     return poDS;
     204             : }
     205             : 
     206             : /************************************************************************/
     207             : /*                               Open()                                 */
     208             : /************************************************************************/
     209             : 
     210             : VSIVirtualHandleUniquePtr
     211          23 : VSIPMTilesFilesystemHandler::Open(const char *pszFilename,
     212             :                                   const char *pszAccess, bool /*bSetError*/,
     213             :                                   CSLConstList /*papszOptions*/)
     214             : {
     215          23 :     if (strchr(pszAccess, '+') || strchr(pszAccess, 'w') ||
     216          22 :         strchr(pszAccess, 'a'))
     217           1 :         return nullptr;
     218          44 :     std::string osSubfilename;
     219             :     int nComponents;
     220             :     int nZ;
     221             :     int nX;
     222             :     int nY;
     223             :     auto poDS =
     224          44 :         VSIPMTilesOpen(pszFilename, osSubfilename, nComponents, nZ, nX, nY);
     225          22 :     if (!poDS)
     226           7 :         return nullptr;
     227             : 
     228          15 :     if (osSubfilename == METADATA_JSON)
     229             :     {
     230             :         return VSIVirtualHandleUniquePtr(
     231             :             VSIFileFromMemBuffer(nullptr,
     232           2 :                                  reinterpret_cast<GByte *>(CPLStrdup(
     233           2 :                                      poDS->GetMetadataContent().c_str())),
     234           4 :                                  poDS->GetMetadataContent().size(), true));
     235             :     }
     236             : 
     237          13 :     if (osSubfilename == PMTILES_HEADER_JSON)
     238             :     {
     239           6 :         const auto osStr = VSIPMTilesGetPMTilesHeaderJson(poDS.get());
     240             :         return VSIVirtualHandleUniquePtr(VSIFileFromMemBuffer(
     241           3 :             nullptr, reinterpret_cast<GByte *>(CPLStrdup(osStr.c_str())),
     242           6 :             osStr.size(), true));
     243             :     }
     244             : 
     245          10 :     if (nComponents != 3)
     246           3 :         return nullptr;
     247             : 
     248          14 :     CPLErrorStateBackuper oBackuper(CPLQuietErrorHandler);
     249             : 
     250          14 :     OGRPMTilesTileIterator oIter(poDS.get(), nZ, nX, nY, nX, nY);
     251           7 :     auto sTile = oIter.GetNextTile();
     252           7 :     if (sTile.offset == 0)
     253           1 :         return nullptr;
     254             : 
     255           6 :     const auto *posStr = poDS->ReadTileData(sTile.offset, sTile.length);
     256           6 :     if (!posStr)
     257             :     {
     258           0 :         return nullptr;
     259             :     }
     260             : 
     261           6 :     GByte *pabyData = static_cast<GByte *>(CPLMalloc(posStr->size()));
     262           6 :     memcpy(pabyData, posStr->data(), posStr->size());
     263             :     return VSIVirtualHandleUniquePtr(
     264           6 :         VSIFileFromMemBuffer(nullptr, pabyData, posStr->size(), true));
     265             : }
     266             : 
     267             : /************************************************************************/
     268             : /*                               Stat()                                 */
     269             : /************************************************************************/
     270             : 
     271          26 : int VSIPMTilesFilesystemHandler::Stat(const char *pszFilename,
     272             :                                       VSIStatBufL *pStatBuf, int /*nFlags*/)
     273             : {
     274          26 :     memset(pStatBuf, 0, sizeof(VSIStatBufL));
     275             : 
     276          52 :     std::string osSubfilename;
     277             :     int nComponents;
     278             :     int nZ;
     279             :     int nX;
     280             :     int nY;
     281             :     auto poDS =
     282          52 :         VSIPMTilesOpen(pszFilename, osSubfilename, nComponents, nZ, nX, nY);
     283          26 :     if (!poDS)
     284           0 :         return -1;
     285             : 
     286          26 :     if (osSubfilename.empty())
     287           0 :         return -1;
     288             : 
     289             :     VSIStatBufL sStatPmtiles;
     290          26 :     if (VSIStatL(poDS->GetDescription(), &sStatPmtiles) == 0)
     291             :     {
     292          26 :         pStatBuf->st_mtime = sStatPmtiles.st_mtime;
     293             :     }
     294             : 
     295          26 :     if (osSubfilename == METADATA_JSON)
     296             :     {
     297           2 :         pStatBuf->st_mode = S_IFREG;
     298           2 :         pStatBuf->st_size = poDS->GetMetadataContent().size();
     299           2 :         return 0;
     300             :     }
     301             : 
     302          24 :     if (osSubfilename == PMTILES_HEADER_JSON)
     303             :     {
     304           1 :         pStatBuf->st_mode = S_IFREG;
     305           1 :         pStatBuf->st_size = VSIPMTilesGetPMTilesHeaderJson(poDS.get()).size();
     306           1 :         return 0;
     307             :     }
     308             : 
     309          46 :     CPLErrorStateBackuper oBackuper(CPLQuietErrorHandler);
     310             : 
     311          46 :     OGRPMTilesTileIterator oIter(poDS.get(), nZ, nX, nY, nX, nY);
     312          23 :     auto sTile = oIter.GetNextTile();
     313          23 :     if (sTile.offset == 0)
     314           1 :         return -1;
     315             : 
     316          22 :     if (nComponents <= 2)
     317             :     {
     318           0 :         pStatBuf->st_mode = S_IFDIR;
     319           0 :         return 0;
     320             :     }
     321             : 
     322          22 :     pStatBuf->st_mode = S_IFREG;
     323          22 :     pStatBuf->st_size = sTile.length;
     324          22 :     return 0;
     325             : }
     326             : 
     327             : /************************************************************************/
     328             : /*                            ReadDirEx()                               */
     329             : /************************************************************************/
     330             : 
     331          10 : char **VSIPMTilesFilesystemHandler::ReadDirEx(const char *pszFilename,
     332             :                                               int nMaxFiles)
     333             : {
     334          20 :     std::string osSubfilename;
     335             :     int nComponents;
     336             :     int nZ;
     337             :     int nX;
     338             :     int nY;
     339             :     auto poDS =
     340          20 :         VSIPMTilesOpen(pszFilename, osSubfilename, nComponents, nZ, nX, nY);
     341          10 :     if (!poDS)
     342           3 :         return nullptr;
     343             : 
     344           7 :     if (osSubfilename.empty())
     345             :     {
     346           2 :         CPLStringList aosFiles;
     347           1 :         aosFiles.AddString(PMTILES_HEADER_JSON);
     348           1 :         aosFiles.AddString(METADATA_JSON);
     349           4 :         for (int i = poDS->GetMinZoomLevel(); i <= poDS->GetMaxZoomLevel(); ++i)
     350             :         {
     351           3 :             OGRPMTilesTileIterator oIter(poDS.get(), i);
     352           3 :             auto sTile = oIter.GetNextTile();
     353           3 :             if (sTile.offset != 0)
     354             :             {
     355           3 :                 if (nMaxFiles > 0 && aosFiles.size() >= nMaxFiles)
     356           0 :                     break;
     357           3 :                 aosFiles.AddString(CPLSPrintf("%d", i));
     358             :             }
     359             :         }
     360           1 :         return aosFiles.StealList();
     361             :     }
     362             : 
     363           6 :     if (nComponents == 1)
     364             :     {
     365           4 :         std::set<int> oSetX;
     366           4 :         OGRPMTilesTileIterator oIter(poDS.get(), nZ);
     367             :         while (true)
     368             :         {
     369           4 :             auto sTile = oIter.GetNextTile();
     370           4 :             if (sTile.offset == 0)
     371           2 :                 break;
     372           2 :             oSetX.insert(sTile.x);
     373           2 :             if (nMaxFiles > 0 && static_cast<int>(oSetX.size()) >= nMaxFiles)
     374           0 :                 break;
     375           2 :             if (oSetX.size() == 1024 * 1024)
     376             :             {
     377           0 :                 CPLError(CE_Failure, CPLE_AppDefined, "Too many tiles");
     378           0 :                 return nullptr;
     379             :             }
     380           2 :         }
     381           4 :         CPLStringList aosFiles;
     382           4 :         for (int x : oSetX)
     383             :         {
     384           2 :             aosFiles.AddString(CPLSPrintf("%d", x));
     385             :         }
     386           2 :         return aosFiles.StealList();
     387             :     }
     388             : 
     389           4 :     if (nComponents == 2)
     390             :     {
     391           6 :         std::set<int> oSetY;
     392           6 :         OGRPMTilesTileIterator oIter(poDS.get(), nZ, nX, -1, nX, -1);
     393             :         while (true)
     394             :         {
     395           4 :             auto sTile = oIter.GetNextTile();
     396           4 :             if (sTile.offset == 0)
     397           3 :                 break;
     398           1 :             oSetY.insert(sTile.y);
     399           1 :             if (nMaxFiles > 0 && static_cast<int>(oSetY.size()) >= nMaxFiles)
     400           0 :                 break;
     401           1 :             if (oSetY.size() == 1024 * 1024)
     402             :             {
     403           0 :                 CPLError(CE_Failure, CPLE_AppDefined, "Too many tiles");
     404           0 :                 return nullptr;
     405             :             }
     406           1 :         }
     407           6 :         CPLStringList aosFiles;
     408           3 :         const char *pszTileExt = VSIPMTilesGetTileExtension(poDS.get());
     409           4 :         for (int y : oSetY)
     410             :         {
     411           1 :             aosFiles.AddString(CPLSPrintf("%d%s", y, pszTileExt));
     412             :         }
     413           3 :         return aosFiles.StealList();
     414             :     }
     415             : 
     416           1 :     return nullptr;
     417             : }
     418             : 
     419             : /************************************************************************/
     420             : /*                         VSIPMTilesRegister()                         */
     421             : /************************************************************************/
     422             : 
     423        1741 : void VSIPMTilesRegister()
     424             : {
     425        1741 :     if (VSIFileManager::GetHandler("/vsipmtiles/") ==
     426        1741 :         VSIFileManager::GetHandler("/"))
     427             :     {
     428        1741 :         VSIFileManager::InstallHandler("/vsipmtiles/",
     429        1741 :                                        new VSIPMTilesFilesystemHandler());
     430             :     }
     431        1741 : }