LCOV - code coverage report
Current view: top level - frmts/webp - webpdataset.cpp (source / functions) Hit Total Coverage
Test: gdal_filtered.info Lines: 341 470 72.6 %
Date: 2025-02-20 10:14:44 Functions: 17 18 94.4 %

          Line data    Source code
       1             : /******************************************************************************
       2             :  *
       3             :  * Project:  GDAL WEBP Driver
       4             :  * Purpose:  Implement GDAL WEBP Support based on libwebp
       5             :  * Author:   Even Rouault, <even dot rouault at spatialys.com>
       6             :  *
       7             :  ******************************************************************************
       8             :  * Copyright (c) 2011-2013, Even Rouault <even dot rouault at spatialys.com>
       9             :  *
      10             :  * SPDX-License-Identifier: MIT
      11             :  ****************************************************************************/
      12             : 
      13             : #include "cpl_string.h"
      14             : #include "gdal_frmts.h"
      15             : #include "gdal_pam.h"
      16             : 
      17             : #include "webp_headers.h"
      18             : #include "webpdrivercore.h"
      19             : 
      20             : #include <limits>
      21             : 
      22             : /************************************************************************/
      23             : /* ==================================================================== */
      24             : /*                               WEBPDataset                            */
      25             : /* ==================================================================== */
      26             : /************************************************************************/
      27             : 
      28             : class WEBPRasterBand;
      29             : 
      30             : class WEBPDataset final : public GDALPamDataset
      31             : {
      32             :     friend class WEBPRasterBand;
      33             : 
      34             :     VSILFILE *fpImage;
      35             :     GByte *pabyUncompressed;
      36             :     int bHasBeenUncompressed;
      37             :     CPLErr eUncompressErrRet;
      38             :     CPLErr Uncompress();
      39             : 
      40             :     int bHasReadXMPMetadata;
      41             : 
      42             :   public:
      43             :     WEBPDataset();
      44             :     virtual ~WEBPDataset();
      45             : 
      46             :     virtual CPLErr IRasterIO(GDALRWFlag, int, int, int, int, void *, int, int,
      47             :                              GDALDataType, int, BANDMAP_TYPE,
      48             :                              GSpacing nPixelSpace, GSpacing nLineSpace,
      49             :                              GSpacing nBandSpace,
      50             :                              GDALRasterIOExtraArg *psExtraArg) override;
      51             : 
      52             :     virtual char **GetMetadataDomainList() override;
      53             :     virtual char **GetMetadata(const char *pszDomain = "") override;
      54             : 
      55             :     CPLStringList GetCompressionFormats(int nXOff, int nYOff, int nXSize,
      56             :                                         int nYSize, int nBandCount,
      57             :                                         const int *panBandList) override;
      58             :     CPLErr ReadCompressedData(const char *pszFormat, int nXOff, int nYOff,
      59             :                               int nXSize, int nYSize, int nBandCount,
      60             :                               const int *panBandList, void **ppBuffer,
      61             :                               size_t *pnBufferSize,
      62             :                               char **ppszDetailedFormat) override;
      63             : 
      64             :     static GDALPamDataset *OpenPAM(GDALOpenInfo *poOpenInfo);
      65             :     static GDALDataset *Open(GDALOpenInfo *);
      66             :     static GDALDataset *CreateCopy(const char *pszFilename,
      67             :                                    GDALDataset *poSrcDS, int bStrict,
      68             :                                    char **papszOptions,
      69             :                                    GDALProgressFunc pfnProgress,
      70             :                                    void *pProgressData);
      71             : };
      72             : 
      73             : /************************************************************************/
      74             : /* ==================================================================== */
      75             : /*                            WEBPRasterBand                            */
      76             : /* ==================================================================== */
      77             : /************************************************************************/
      78             : 
      79             : class WEBPRasterBand final : public GDALPamRasterBand
      80             : {
      81             :     friend class WEBPDataset;
      82             : 
      83             :   public:
      84             :     WEBPRasterBand(WEBPDataset *, int);
      85             : 
      86             :     virtual CPLErr IReadBlock(int, int, void *) override;
      87             :     virtual GDALColorInterp GetColorInterpretation() override;
      88             : };
      89             : 
      90             : /************************************************************************/
      91             : /*                          WEBPRasterBand()                            */
      92             : /************************************************************************/
      93             : 
      94        1697 : WEBPRasterBand::WEBPRasterBand(WEBPDataset *poDSIn, int)
      95             : {
      96        1697 :     poDS = poDSIn;
      97             : 
      98        1697 :     eDataType = GDT_Byte;
      99             : 
     100        1697 :     nBlockXSize = poDSIn->nRasterXSize;
     101        1697 :     nBlockYSize = 1;
     102        1697 : }
     103             : 
     104             : /************************************************************************/
     105             : /*                             IReadBlock()                             */
     106             : /************************************************************************/
     107             : 
     108       11626 : CPLErr WEBPRasterBand::IReadBlock(CPL_UNUSED int nBlockXOff, int nBlockYOff,
     109             :                                   void *pImage)
     110             : {
     111       11626 :     WEBPDataset *poGDS = reinterpret_cast<WEBPDataset *>(poDS);
     112             : 
     113       11626 :     if (poGDS->Uncompress() != CE_None)
     114           0 :         return CE_Failure;
     115             : 
     116       11626 :     GByte *pabyUncompressed =
     117       11626 :         &poGDS->pabyUncompressed[nBlockYOff * nRasterXSize * poGDS->nBands +
     118       11626 :                                  nBand - 1];
     119     2882680 :     for (int i = 0; i < nRasterXSize; i++)
     120     2871060 :         reinterpret_cast<GByte *>(pImage)[i] =
     121     2871060 :             pabyUncompressed[poGDS->nBands * i];
     122             : 
     123       11626 :     return CE_None;
     124             : }
     125             : 
     126             : /************************************************************************/
     127             : /*                       GetColorInterpretation()                       */
     128             : /************************************************************************/
     129             : 
     130          78 : GDALColorInterp WEBPRasterBand::GetColorInterpretation()
     131             : 
     132             : {
     133          78 :     if (nBand == 1)
     134          25 :         return GCI_RedBand;
     135             : 
     136          53 :     else if (nBand == 2)
     137          25 :         return GCI_GreenBand;
     138             : 
     139          28 :     else if (nBand == 3)
     140          25 :         return GCI_BlueBand;
     141             : 
     142           3 :     return GCI_AlphaBand;
     143             : }
     144             : 
     145             : /************************************************************************/
     146             : /* ==================================================================== */
     147             : /*                             WEBPDataset                               */
     148             : /* ==================================================================== */
     149             : /************************************************************************/
     150             : 
     151             : /************************************************************************/
     152             : /*                            WEBPDataset()                              */
     153             : /************************************************************************/
     154             : 
     155         467 : WEBPDataset::WEBPDataset()
     156             :     : fpImage(nullptr), pabyUncompressed(nullptr), bHasBeenUncompressed(FALSE),
     157         467 :       eUncompressErrRet(CE_None), bHasReadXMPMetadata(FALSE)
     158             : {
     159         467 : }
     160             : 
     161             : /************************************************************************/
     162             : /*                           ~WEBPDataset()                             */
     163             : /************************************************************************/
     164             : 
     165         934 : WEBPDataset::~WEBPDataset()
     166             : 
     167             : {
     168         467 :     FlushCache(true);
     169         467 :     if (fpImage)
     170         467 :         VSIFCloseL(fpImage);
     171         467 :     VSIFree(pabyUncompressed);
     172         934 : }
     173             : 
     174             : /************************************************************************/
     175             : /*                      GetMetadataDomainList()                         */
     176             : /************************************************************************/
     177             : 
     178           1 : char **WEBPDataset::GetMetadataDomainList()
     179             : {
     180           1 :     return BuildMetadataDomainList(GDALPamDataset::GetMetadataDomainList(),
     181           1 :                                    TRUE, "xml:XMP", nullptr);
     182             : }
     183             : 
     184             : /************************************************************************/
     185             : /*                           GetMetadata()                              */
     186             : /************************************************************************/
     187             : 
     188          52 : char **WEBPDataset::GetMetadata(const char *pszDomain)
     189             : {
     190          52 :     if ((pszDomain != nullptr && EQUAL(pszDomain, "xml:XMP")) &&
     191           4 :         !bHasReadXMPMetadata)
     192             :     {
     193           4 :         bHasReadXMPMetadata = TRUE;
     194             : 
     195           4 :         VSIFSeekL(fpImage, 12, SEEK_SET);
     196             : 
     197           4 :         bool bFirst = true;
     198             :         while (true)
     199             :         {
     200             :             char szHeader[5];
     201             :             GUInt32 nChunkSize;
     202             : 
     203          16 :             if (VSIFReadL(szHeader, 1, 4, fpImage) != 4 ||
     204           8 :                 VSIFReadL(&nChunkSize, 1, 4, fpImage) != 4)
     205           4 :                 break;
     206             : 
     207           8 :             szHeader[4] = '\0';
     208           8 :             CPL_LSBPTR32(&nChunkSize);
     209             : 
     210           8 :             if (bFirst)
     211             :             {
     212           4 :                 if (strcmp(szHeader, "VP8X") != 0 || nChunkSize < 10)
     213             :                     break;
     214             : 
     215             :                 int l_nFlags;
     216           2 :                 if (VSIFReadL(&l_nFlags, 1, 4, fpImage) != 4)
     217           0 :                     break;
     218           2 :                 CPL_LSBPTR32(&l_nFlags);
     219           2 :                 if ((l_nFlags & 8) == 0)
     220           0 :                     break;
     221             : 
     222           2 :                 VSIFSeekL(fpImage, nChunkSize - 4, SEEK_CUR);
     223             : 
     224           2 :                 bFirst = false;
     225             :             }
     226           4 :             else if (strcmp(szHeader, "META") == 0)
     227             :             {
     228           2 :                 if (nChunkSize > 1024 * 1024)
     229           0 :                     break;
     230             : 
     231             :                 char *pszXMP =
     232           2 :                     reinterpret_cast<char *>(VSIMalloc(nChunkSize + 1));
     233           2 :                 if (pszXMP == nullptr)
     234           0 :                     break;
     235             : 
     236           2 :                 if (static_cast<GUInt32>(VSIFReadL(pszXMP, 1, nChunkSize,
     237           2 :                                                    fpImage)) != nChunkSize)
     238             :                 {
     239           0 :                     VSIFree(pszXMP);
     240           0 :                     break;
     241             :                 }
     242           2 :                 pszXMP[nChunkSize] = '\0';
     243             : 
     244             :                 /* Avoid setting the PAM dirty bit just for that */
     245           2 :                 const int nOldPamFlags = nPamFlags;
     246             : 
     247           2 :                 char *apszMDList[2] = {pszXMP, nullptr};
     248           2 :                 SetMetadata(apszMDList, "xml:XMP");
     249             : 
     250             :                 // cppcheck-suppress redundantAssignment
     251           2 :                 nPamFlags = nOldPamFlags;
     252             : 
     253           2 :                 VSIFree(pszXMP);
     254           2 :                 break;
     255             :             }
     256             :             else
     257           2 :                 VSIFSeekL(fpImage, nChunkSize, SEEK_CUR);
     258           4 :         }
     259             :     }
     260             : 
     261          52 :     return GDALPamDataset::GetMetadata(pszDomain);
     262             : }
     263             : 
     264             : /************************************************************************/
     265             : /*                            Uncompress()                              */
     266             : /************************************************************************/
     267             : 
     268       11943 : CPLErr WEBPDataset::Uncompress()
     269             : {
     270       11943 :     if (bHasBeenUncompressed)
     271       11605 :         return eUncompressErrRet;
     272             : 
     273         338 :     bHasBeenUncompressed = TRUE;
     274         338 :     eUncompressErrRet = CE_Failure;
     275             : 
     276             :     // To avoid excessive memory allocation attempts
     277             :     // Normally WebP images are no larger than 16383x16383*4 ~= 1 GB
     278         338 :     if (nRasterXSize > INT_MAX / (nRasterYSize * nBands))
     279             :     {
     280           0 :         CPLError(CE_Failure, CPLE_NotSupported, "Too large image");
     281           0 :         return CE_Failure;
     282             :     }
     283             : 
     284         338 :     pabyUncompressed = reinterpret_cast<GByte *>(
     285         338 :         VSIMalloc3(nRasterXSize, nRasterYSize, nBands));
     286         338 :     if (pabyUncompressed == nullptr)
     287           0 :         return CE_Failure;
     288             : 
     289         338 :     VSIFSeekL(fpImage, 0, SEEK_END);
     290         338 :     vsi_l_offset nSizeLarge = VSIFTellL(fpImage);
     291         338 :     if (nSizeLarge !=
     292         338 :         static_cast<vsi_l_offset>(static_cast<uint32_t>(nSizeLarge)))
     293           0 :         return CE_Failure;
     294         338 :     VSIFSeekL(fpImage, 0, SEEK_SET);
     295         338 :     uint32_t nSize = static_cast<uint32_t>(nSizeLarge);
     296         338 :     uint8_t *pabyCompressed = reinterpret_cast<uint8_t *>(VSIMalloc(nSize));
     297         338 :     if (pabyCompressed == nullptr)
     298           0 :         return CE_Failure;
     299         338 :     VSIFReadL(pabyCompressed, 1, nSize, fpImage);
     300             :     uint8_t *pRet;
     301             : 
     302         338 :     if (nBands == 4)
     303         216 :         pRet = WebPDecodeRGBAInto(pabyCompressed, static_cast<uint32_t>(nSize),
     304         216 :                                   static_cast<uint8_t *>(pabyUncompressed),
     305         216 :                                   static_cast<size_t>(nRasterXSize) *
     306         216 :                                       nRasterYSize * nBands,
     307         216 :                                   nRasterXSize * nBands);
     308             :     else
     309         122 :         pRet = WebPDecodeRGBInto(pabyCompressed, static_cast<uint32_t>(nSize),
     310         122 :                                  static_cast<uint8_t *>(pabyUncompressed),
     311         122 :                                  static_cast<size_t>(nRasterXSize) *
     312         122 :                                      nRasterYSize * nBands,
     313         122 :                                  nRasterXSize * nBands);
     314             : 
     315         338 :     VSIFree(pabyCompressed);
     316         338 :     if (pRet == nullptr)
     317             :     {
     318           0 :         CPLError(CE_Failure, CPLE_AppDefined, "WebPDecodeRGBInto() failed");
     319           0 :         return CE_Failure;
     320             :     }
     321         338 :     eUncompressErrRet = CE_None;
     322             : 
     323         338 :     return CE_None;
     324             : }
     325             : 
     326             : /************************************************************************/
     327             : /*                             IRasterIO()                              */
     328             : /************************************************************************/
     329             : 
     330         321 : CPLErr WEBPDataset::IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
     331             :                               int nXSize, int nYSize, void *pData,
     332             :                               int nBufXSize, int nBufYSize,
     333             :                               GDALDataType eBufType, int nBandCount,
     334             :                               BANDMAP_TYPE panBandMap, GSpacing nPixelSpace,
     335             :                               GSpacing nLineSpace, GSpacing nBandSpace,
     336             :                               GDALRasterIOExtraArg *psExtraArg)
     337             : 
     338             : {
     339         321 :     if ((eRWFlag == GF_Read) && (nBandCount == nBands) && (nXOff == 0) &&
     340         321 :         (nYOff == 0) && (nXSize == nBufXSize) && (nXSize == nRasterXSize) &&
     341         317 :         (nYSize == nBufYSize) && (nYSize == nRasterYSize) &&
     342         317 :         (eBufType == GDT_Byte) && (pData != nullptr) && (panBandMap[0] == 1) &&
     343         317 :         (panBandMap[1] == 2) && (panBandMap[2] == 3) &&
     344         317 :         (nBands == 3 || panBandMap[3] == 4))
     345             :     {
     346         317 :         if (Uncompress() != CE_None)
     347           0 :             return CE_Failure;
     348         317 :         if (nPixelSpace == nBands && nLineSpace == (nPixelSpace * nXSize) &&
     349             :             nBandSpace == 1)
     350             :         {
     351          77 :             memcpy(pData, pabyUncompressed,
     352          77 :                    static_cast<size_t>(nBands) * nXSize * nYSize);
     353             :         }
     354             :         else
     355             :         {
     356        8024 :             for (int y = 0; y < nYSize; ++y)
     357             :             {
     358        7784 :                 GByte *pabyScanline = pabyUncompressed + y * nBands * nXSize;
     359     1101290 :                 for (int x = 0; x < nXSize; ++x)
     360             :                 {
     361     5276670 :                     for (int iBand = 0; iBand < nBands; iBand++)
     362             :                         reinterpret_cast<GByte *>(
     363     4183170 :                             pData)[(y * nLineSpace) + (x * nPixelSpace) +
     364     4183170 :                                    iBand * nBandSpace] =
     365     4183170 :                             pabyScanline[x * nBands + iBand];
     366             :                 }
     367             :             }
     368             :         }
     369             : 
     370         317 :         return CE_None;
     371             :     }
     372             : 
     373           4 :     return GDALPamDataset::IRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize,
     374             :                                      pData, nBufXSize, nBufYSize, eBufType,
     375             :                                      nBandCount, panBandMap, nPixelSpace,
     376           4 :                                      nLineSpace, nBandSpace, psExtraArg);
     377             : }
     378             : 
     379             : /************************************************************************/
     380             : /*                       GetCompressionFormats()                        */
     381             : /************************************************************************/
     382             : 
     383           0 : CPLStringList WEBPDataset::GetCompressionFormats(int nXOff, int nYOff,
     384             :                                                  int nXSize, int nYSize,
     385             :                                                  int nBandCount,
     386             :                                                  const int *panBandList)
     387             : {
     388           0 :     CPLStringList aosRet;
     389           0 :     if (nXOff == 0 && nYOff == 0 && nXSize == nRasterXSize &&
     390           0 :         nYSize == nRasterYSize && IsAllBands(nBandCount, panBandList))
     391             :     {
     392           0 :         aosRet.AddString("WEBP");
     393             :     }
     394           0 :     return aosRet;
     395             : }
     396             : 
     397             : /************************************************************************/
     398             : /*                       ReadCompressedData()                           */
     399             : /************************************************************************/
     400             : 
     401           2 : CPLErr WEBPDataset::ReadCompressedData(const char *pszFormat, int nXOff,
     402             :                                        int nYOff, int nXSize, int nYSize,
     403             :                                        int nBandCount, const int *panBandList,
     404             :                                        void **ppBuffer, size_t *pnBufferSize,
     405             :                                        char **ppszDetailedFormat)
     406             : {
     407           2 :     if (nXOff == 0 && nYOff == 0 && nXSize == nRasterXSize &&
     408           4 :         nYSize == nRasterYSize && IsAllBands(nBandCount, panBandList))
     409             :     {
     410           2 :         const CPLStringList aosTokens(CSLTokenizeString2(pszFormat, ";", 0));
     411           2 :         if (aosTokens.size() != 1)
     412           0 :             return CE_Failure;
     413             : 
     414           2 :         if (EQUAL(aosTokens[0], "WEBP"))
     415             :         {
     416           2 :             if (ppszDetailedFormat)
     417           0 :                 *ppszDetailedFormat = VSIStrdup("WEBP");
     418           2 :             VSIFSeekL(fpImage, 0, SEEK_END);
     419           2 :             const auto nFileSize = VSIFTellL(fpImage);
     420           2 :             if (nFileSize > std::numeric_limits<uint32_t>::max())
     421           0 :                 return CE_Failure;
     422           2 :             auto nSize = static_cast<uint32_t>(nFileSize);
     423           2 :             if (ppBuffer)
     424             :             {
     425           2 :                 if (!pnBufferSize)
     426           0 :                     return CE_Failure;
     427           2 :                 bool bFreeOnError = false;
     428           2 :                 if (*ppBuffer)
     429             :                 {
     430           0 :                     if (*pnBufferSize < nSize)
     431           0 :                         return CE_Failure;
     432             :                 }
     433             :                 else
     434             :                 {
     435           2 :                     *ppBuffer = VSI_MALLOC_VERBOSE(nSize);
     436           2 :                     if (*ppBuffer == nullptr)
     437           0 :                         return CE_Failure;
     438           2 :                     bFreeOnError = true;
     439             :                 }
     440           2 :                 VSIFSeekL(fpImage, 0, SEEK_SET);
     441           2 :                 if (VSIFReadL(*ppBuffer, nSize, 1, fpImage) != 1)
     442             :                 {
     443           0 :                     if (bFreeOnError)
     444             :                     {
     445           0 :                         VSIFree(*ppBuffer);
     446           0 :                         *ppBuffer = nullptr;
     447             :                     }
     448           0 :                     return CE_Failure;
     449             :                 }
     450             : 
     451             :                 // Remove META box
     452           2 :                 if (nSize > 12 && memcmp(*ppBuffer, "RIFF", 4) == 0)
     453             :                 {
     454           2 :                     size_t nPos = 12;
     455           2 :                     GByte *pabyData = static_cast<GByte *>(*ppBuffer);
     456           6 :                     while (nPos <= nSize - 8)
     457             :                     {
     458           4 :                         char szBoxName[5] = {0, 0, 0, 0, 0};
     459           4 :                         memcpy(szBoxName, pabyData + nPos, 4);
     460             :                         uint32_t nChunkSize;
     461           4 :                         memcpy(&nChunkSize, pabyData + nPos + 4, 4);
     462           4 :                         CPL_LSBPTR32(&nChunkSize);
     463           4 :                         if (nChunkSize % 2)  // Payload padding if needed
     464           1 :                             nChunkSize++;
     465           4 :                         if (nChunkSize > nSize - (nPos + 8))
     466           0 :                             break;
     467           4 :                         if (memcmp(szBoxName, "META", 4) == 0)
     468             :                         {
     469           1 :                             CPLDebug("WEBP",
     470             :                                      "Remove existing %s box from "
     471             :                                      "source compressed data",
     472             :                                      szBoxName);
     473           1 :                             if (nPos + 8 + nChunkSize < nSize)
     474             :                             {
     475           0 :                                 memmove(pabyData + nPos,
     476           0 :                                         pabyData + nPos + 8 + nChunkSize,
     477           0 :                                         nSize - (nPos + 8 + nChunkSize));
     478             :                             }
     479           1 :                             nSize -= 8 + nChunkSize;
     480             :                         }
     481             :                         else
     482             :                         {
     483           3 :                             nPos += 8 + nChunkSize;
     484             :                         }
     485             :                     }
     486             : 
     487             :                     // Patch size of RIFF
     488           2 :                     uint32_t nSize32 = nSize - 8;
     489           2 :                     CPL_LSBPTR32(&nSize32);
     490           2 :                     memcpy(pabyData + 4, &nSize32, 4);
     491             :                 }
     492             :             }
     493           2 :             if (pnBufferSize)
     494           2 :                 *pnBufferSize = nSize;
     495           2 :             return CE_None;
     496             :         }
     497             :     }
     498           0 :     return CE_Failure;
     499             : }
     500             : 
     501             : /************************************************************************/
     502             : /*                          OpenPAM()                                   */
     503             : /************************************************************************/
     504             : 
     505         467 : GDALPamDataset *WEBPDataset::OpenPAM(GDALOpenInfo *poOpenInfo)
     506             : 
     507             : {
     508         467 :     if (!WEBPDriverIdentify(poOpenInfo) || poOpenInfo->fpL == nullptr)
     509           0 :         return nullptr;
     510             : 
     511             :     int nWidth, nHeight;
     512         467 :     if (!WebPGetInfo(reinterpret_cast<const uint8_t *>(poOpenInfo->pabyHeader),
     513         467 :                      static_cast<uint32_t>(poOpenInfo->nHeaderBytes), &nWidth,
     514             :                      &nHeight))
     515           0 :         return nullptr;
     516             : 
     517         467 :     int nBands = 3;
     518             : 
     519         934 :     auto poDS = std::make_unique<WEBPDataset>();
     520             : 
     521             : #if WEBP_DECODER_ABI_VERSION >= 0x0002
     522             :     WebPDecoderConfig config;
     523         467 :     if (!WebPInitDecoderConfig(&config))
     524           0 :         return nullptr;
     525             : 
     526             :     const bool bOK =
     527         467 :         WebPGetFeatures(poOpenInfo->pabyHeader, poOpenInfo->nHeaderBytes,
     528         467 :                         &config.input) == VP8_STATUS_OK;
     529             : 
     530             :     // Cf commit https://github.com/webmproject/libwebp/commit/86c0031eb2c24f78d4dcfc5dab752ebc9f511607#diff-859d219dccb3163cc11cd538effed461ff0145135070abfe70bd263f16408023
     531             :     // Added in webp 0.4.0
     532             : #if WEBP_DECODER_ABI_VERSION >= 0x0202
     533         934 :     poDS->GDALDataset::SetMetadataItem(
     534             :         "COMPRESSION_REVERSIBILITY",
     535         467 :         config.input.format == 2 ? "LOSSLESS" : "LOSSY", "IMAGE_STRUCTURE");
     536             : #endif
     537             : 
     538         467 :     if (config.input.has_alpha)
     539         296 :         nBands = 4;
     540             : 
     541         467 :     WebPFreeDecBuffer(&config.output);
     542             : 
     543         467 :     if (!bOK)
     544           0 :         return nullptr;
     545             : 
     546             : #endif
     547             : 
     548         467 :     if (poOpenInfo->eAccess == GA_Update)
     549             :     {
     550           0 :         ReportUpdateNotSupportedByDriver("WEBP");
     551           0 :         return nullptr;
     552             :     }
     553             : 
     554             :     /* -------------------------------------------------------------------- */
     555             :     /*      Create a corresponding GDALDataset.                             */
     556             :     /* -------------------------------------------------------------------- */
     557         467 :     poDS->nRasterXSize = nWidth;
     558         467 :     poDS->nRasterYSize = nHeight;
     559         467 :     poDS->fpImage = poOpenInfo->fpL;
     560         467 :     poOpenInfo->fpL = nullptr;
     561             : 
     562             :     /* -------------------------------------------------------------------- */
     563             :     /*      Create band information objects.                                */
     564             :     /* -------------------------------------------------------------------- */
     565        2164 :     for (int iBand = 0; iBand < nBands; iBand++)
     566        1697 :         poDS->SetBand(iBand + 1, new WEBPRasterBand(poDS.get(), iBand + 1));
     567             : 
     568             :     /* -------------------------------------------------------------------- */
     569             :     /*      Initialize any PAM information.                                 */
     570             :     /* -------------------------------------------------------------------- */
     571         467 :     poDS->SetDescription(poOpenInfo->pszFilename);
     572             : 
     573         467 :     poDS->TryLoadXML(poOpenInfo->GetSiblingFiles());
     574             : 
     575             :     /* -------------------------------------------------------------------- */
     576             :     /*      Open overviews.                                                 */
     577             :     /* -------------------------------------------------------------------- */
     578         934 :     poDS->oOvManager.Initialize(poDS.get(), poOpenInfo->pszFilename,
     579         467 :                                 poOpenInfo->GetSiblingFiles());
     580             : 
     581         467 :     return poDS.release();
     582             : }
     583             : 
     584             : /************************************************************************/
     585             : /*                             Open()                                   */
     586             : /************************************************************************/
     587             : 
     588         362 : GDALDataset *WEBPDataset::Open(GDALOpenInfo *poOpenInfo)
     589             : 
     590             : {
     591         362 :     return OpenPAM(poOpenInfo);
     592             : }
     593             : 
     594             : /************************************************************************/
     595             : /*                              WebPUserData                            */
     596             : /************************************************************************/
     597             : 
     598             : typedef struct
     599             : {
     600             :     VSILFILE *fp;
     601             :     GDALProgressFunc pfnProgress;
     602             :     void *pProgressData;
     603             : } WebPUserData;
     604             : 
     605             : /************************************************************************/
     606             : /*                         WEBPDatasetWriter()                          */
     607             : /************************************************************************/
     608             : 
     609         843 : static int WEBPDatasetWriter(const uint8_t *data, size_t data_size,
     610             :                              const WebPPicture *const picture)
     611             : {
     612         843 :     WebPUserData *pUserData =
     613             :         reinterpret_cast<WebPUserData *>(picture->custom_ptr);
     614         843 :     return VSIFWriteL(data, 1, data_size, pUserData->fp) == data_size;
     615             : }
     616             : 
     617             : /************************************************************************/
     618             : /*                        WEBPDatasetProgressHook()                     */
     619             : /************************************************************************/
     620             : 
     621             : #if WEBP_ENCODER_ABI_VERSION >= 0x0100
     622         972 : static int WEBPDatasetProgressHook(int percent,
     623             :                                    const WebPPicture *const picture)
     624             : {
     625         972 :     WebPUserData *pUserData =
     626             :         reinterpret_cast<WebPUserData *>(picture->custom_ptr);
     627         972 :     return pUserData->pfnProgress(percent / 100.0, nullptr,
     628         972 :                                   pUserData->pProgressData);
     629             : }
     630             : #endif
     631             : 
     632             : /************************************************************************/
     633             : /*                              CreateCopy()                            */
     634             : /************************************************************************/
     635             : 
     636         132 : GDALDataset *WEBPDataset::CreateCopy(const char *pszFilename,
     637             :                                      GDALDataset *poSrcDS, int bStrict,
     638             :                                      char **papszOptions,
     639             :                                      GDALProgressFunc pfnProgress,
     640             :                                      void *pProgressData)
     641             : 
     642             : {
     643             :     const char *pszLossLessCopy =
     644         132 :         CSLFetchNameValueDef(papszOptions, "LOSSLESS_COPY", "AUTO");
     645         132 :     if (EQUAL(pszLossLessCopy, "AUTO") || CPLTestBool(pszLossLessCopy))
     646             :     {
     647         132 :         void *pWEBPContent = nullptr;
     648         132 :         size_t nWEBPContent = 0;
     649         132 :         if (poSrcDS->ReadCompressedData(
     650             :                 "WEBP", 0, 0, poSrcDS->GetRasterXSize(),
     651             :                 poSrcDS->GetRasterYSize(), poSrcDS->GetRasterCount(), nullptr,
     652         264 :                 &pWEBPContent, &nWEBPContent, nullptr) == CE_None)
     653             :         {
     654           2 :             CPLDebug("WEBP", "Lossless copy from source dataset");
     655           2 :             std::vector<GByte> abyData;
     656             :             try
     657             :             {
     658           2 :                 abyData.assign(static_cast<const GByte *>(pWEBPContent),
     659           2 :                                static_cast<const GByte *>(pWEBPContent) +
     660           2 :                                    nWEBPContent);
     661             : 
     662           2 :                 char **papszXMP = poSrcDS->GetMetadata("xml:XMP");
     663           2 :                 if (papszXMP && papszXMP[0])
     664             :                 {
     665             :                     GByte abyChunkHeader[8];
     666           1 :                     memcpy(abyChunkHeader, "META", 4);
     667           1 :                     const size_t nXMPSize = strlen(papszXMP[0]);
     668           1 :                     uint32_t nChunkSize = static_cast<uint32_t>(nXMPSize);
     669           1 :                     CPL_LSBPTR32(&nChunkSize);
     670           1 :                     memcpy(abyChunkHeader + 4, &nChunkSize, 4);
     671           0 :                     abyData.insert(abyData.end(), abyChunkHeader,
     672           1 :                                    abyChunkHeader + sizeof(abyChunkHeader));
     673             :                     abyData.insert(
     674           0 :                         abyData.end(), reinterpret_cast<GByte *>(papszXMP[0]),
     675           1 :                         reinterpret_cast<GByte *>(papszXMP[0]) + nXMPSize);
     676           1 :                     if ((abyData.size() % 2) != 0)  // Payload padding if needed
     677           1 :                         abyData.push_back(0);
     678             : 
     679             :                     // Patch size of RIFF
     680             :                     uint32_t nSize32 =
     681           1 :                         static_cast<uint32_t>(abyData.size()) - 8;
     682           1 :                     CPL_LSBPTR32(&nSize32);
     683           1 :                     memcpy(abyData.data() + 4, &nSize32, 4);
     684             :                 }
     685             :             }
     686           0 :             catch (const std::exception &e)
     687             :             {
     688           0 :                 CPLError(CE_Failure, CPLE_AppDefined, "Exception occurred: %s",
     689           0 :                          e.what());
     690           0 :                 abyData.clear();
     691             :             }
     692           2 :             VSIFree(pWEBPContent);
     693             : 
     694           2 :             if (!abyData.empty())
     695             :             {
     696           2 :                 VSILFILE *fpImage = VSIFOpenL(pszFilename, "wb");
     697           2 :                 if (fpImage == nullptr)
     698             :                 {
     699           0 :                     CPLError(CE_Failure, CPLE_OpenFailed,
     700             :                              "Unable to create jpeg file %s.", pszFilename);
     701             : 
     702           0 :                     return nullptr;
     703             :                 }
     704           4 :                 if (VSIFWriteL(abyData.data(), 1, abyData.size(), fpImage) !=
     705           2 :                     abyData.size())
     706             :                 {
     707           0 :                     CPLError(CE_Failure, CPLE_FileIO,
     708           0 :                              "Failure writing data: %s", VSIStrerror(errno));
     709           0 :                     VSIFCloseL(fpImage);
     710           0 :                     return nullptr;
     711             :                 }
     712           2 :                 if (VSIFCloseL(fpImage) != 0)
     713             :                 {
     714           0 :                     CPLError(CE_Failure, CPLE_FileIO,
     715           0 :                              "Failure writing data: %s", VSIStrerror(errno));
     716           0 :                     return nullptr;
     717             :                 }
     718             : 
     719           2 :                 pfnProgress(1.0, nullptr, pProgressData);
     720             : 
     721             :                 // Re-open file and clone missing info to PAM
     722           2 :                 GDALOpenInfo oOpenInfo(pszFilename, GA_ReadOnly);
     723           2 :                 auto poDS = OpenPAM(&oOpenInfo);
     724           2 :                 if (poDS)
     725             :                 {
     726           2 :                     poDS->CloneInfo(poSrcDS, GCIF_PAM_DEFAULT);
     727             :                 }
     728             : 
     729           2 :                 return poDS;
     730             :             }
     731             :         }
     732             :     }
     733             : 
     734         130 :     const bool bLossless = CPLFetchBool(papszOptions, "LOSSLESS", false);
     735         251 :     if (!bLossless &&
     736         121 :         (!EQUAL(pszLossLessCopy, "AUTO") && CPLTestBool(pszLossLessCopy)))
     737             :     {
     738           0 :         CPLError(CE_Failure, CPLE_AppDefined,
     739             :                  "LOSSLESS_COPY=YES requested but not possible");
     740           0 :         return nullptr;
     741             :     }
     742             : 
     743             :     /* -------------------------------------------------------------------- */
     744             :     /*      WEBP library initialization                                     */
     745             :     /* -------------------------------------------------------------------- */
     746             : 
     747             :     WebPPicture sPicture;
     748         130 :     if (!WebPPictureInit(&sPicture))
     749             :     {
     750           0 :         CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureInit() failed");
     751           0 :         return nullptr;
     752             :     }
     753             : 
     754             :     /* -------------------------------------------------------------------- */
     755             :     /*      Some some rudimentary checks                                    */
     756             :     /* -------------------------------------------------------------------- */
     757             : 
     758         130 :     const int nXSize = poSrcDS->GetRasterXSize();
     759         130 :     const int nYSize = poSrcDS->GetRasterYSize();
     760         130 :     if (nXSize > 16383 || nYSize > 16383)
     761             :     {
     762           0 :         CPLError(CE_Failure, CPLE_NotSupported,
     763             :                  "WEBP maximum image dimensions are 16383 x 16383.");
     764             : 
     765           0 :         return nullptr;
     766             :     }
     767             : 
     768         130 :     const int nBands = poSrcDS->GetRasterCount();
     769         130 :     if (nBands != 3
     770             : #if WEBP_ENCODER_ABI_VERSION >= 0x0100
     771          96 :         && nBands != 4
     772             : #endif
     773             :     )
     774             :     {
     775          14 :         CPLError(CE_Failure, CPLE_NotSupported,
     776             :                  "WEBP driver doesn't support %d bands. Must be 3 (RGB) "
     777             : #if WEBP_ENCODER_ABI_VERSION >= 0x0100
     778             :                  "or 4 (RGBA) "
     779             : #endif
     780             :                  "bands.",
     781             :                  nBands);
     782             : 
     783          14 :         return nullptr;
     784             :     }
     785             : 
     786         116 :     const GDALDataType eDT = poSrcDS->GetRasterBand(1)->GetRasterDataType();
     787             : 
     788         116 :     if (eDT != GDT_Byte)
     789             :     {
     790           0 :         CPLError((bStrict) ? CE_Failure : CE_Warning, CPLE_NotSupported,
     791             :                  "WEBP driver doesn't support data type %s. "
     792             :                  "Only eight bit byte bands supported.",
     793             :                  GDALGetDataTypeName(
     794             :                      poSrcDS->GetRasterBand(1)->GetRasterDataType()));
     795             : 
     796           0 :         if (bStrict)
     797           0 :             return nullptr;
     798             :     }
     799             : 
     800             :     /* -------------------------------------------------------------------- */
     801             :     /*      What options has the user selected?                             */
     802             :     /* -------------------------------------------------------------------- */
     803         116 :     float fQuality = 75.0f;
     804         116 :     const char *pszQUALITY = CSLFetchNameValue(papszOptions, "QUALITY");
     805         116 :     if (pszQUALITY != nullptr)
     806             :     {
     807          91 :         fQuality = static_cast<float>(CPLAtof(pszQUALITY));
     808          91 :         if (fQuality < 0.0f || fQuality > 100.0f)
     809             :         {
     810           0 :             CPLError(CE_Failure, CPLE_IllegalArg, "%s=%s is not a legal value.",
     811             :                      "QUALITY", pszQUALITY);
     812           0 :             return nullptr;
     813             :         }
     814             :     }
     815             : 
     816         116 :     WebPPreset nPreset = WEBP_PRESET_DEFAULT;
     817             :     const char *pszPRESET =
     818         116 :         CSLFetchNameValueDef(papszOptions, "PRESET", "DEFAULT");
     819         116 :     if (EQUAL(pszPRESET, "DEFAULT"))
     820         116 :         nPreset = WEBP_PRESET_DEFAULT;
     821           0 :     else if (EQUAL(pszPRESET, "PICTURE"))
     822           0 :         nPreset = WEBP_PRESET_PICTURE;
     823           0 :     else if (EQUAL(pszPRESET, "PHOTO"))
     824           0 :         nPreset = WEBP_PRESET_PHOTO;
     825           0 :     else if (EQUAL(pszPRESET, "PICTURE"))
     826           0 :         nPreset = WEBP_PRESET_PICTURE;
     827           0 :     else if (EQUAL(pszPRESET, "DRAWING"))
     828           0 :         nPreset = WEBP_PRESET_DRAWING;
     829           0 :     else if (EQUAL(pszPRESET, "ICON"))
     830           0 :         nPreset = WEBP_PRESET_ICON;
     831           0 :     else if (EQUAL(pszPRESET, "TEXT"))
     832           0 :         nPreset = WEBP_PRESET_TEXT;
     833             :     else
     834             :     {
     835           0 :         CPLError(CE_Failure, CPLE_IllegalArg, "%s=%s is not a legal value.",
     836             :                  "PRESET", pszPRESET);
     837           0 :         return nullptr;
     838             :     }
     839             : 
     840             :     WebPConfig sConfig;
     841         116 :     if (!WebPConfigInitInternal(&sConfig, nPreset, fQuality,
     842             :                                 WEBP_ENCODER_ABI_VERSION))
     843             :     {
     844           0 :         CPLError(CE_Failure, CPLE_AppDefined, "WebPConfigInit() failed");
     845           0 :         return nullptr;
     846             :     }
     847             : 
     848             :     // TODO: Get rid of this macro in a reasonable way.
     849             : #define FETCH_AND_SET_OPTION_INT(name, fieldname, minval, maxval)              \
     850             :     {                                                                          \
     851             :         const char *pszVal = CSLFetchNameValue(papszOptions, name);            \
     852             :         if (pszVal != nullptr)                                                 \
     853             :         {                                                                      \
     854             :             sConfig.fieldname = atoi(pszVal);                                  \
     855             :             if (sConfig.fieldname < minval || sConfig.fieldname > maxval)      \
     856             :             {                                                                  \
     857             :                 CPLError(CE_Failure, CPLE_IllegalArg,                          \
     858             :                          "%s=%s is not a legal value.", name, pszVal);         \
     859             :                 return nullptr;                                                \
     860             :             }                                                                  \
     861             :         }                                                                      \
     862             :     }
     863             : 
     864         116 :     FETCH_AND_SET_OPTION_INT("TARGETSIZE", target_size, 0, INT_MAX - 1);
     865             : 
     866         116 :     const char *pszPSNR = CSLFetchNameValue(papszOptions, "PSNR");
     867         116 :     if (pszPSNR)
     868             :     {
     869           0 :         sConfig.target_PSNR = static_cast<float>(CPLAtof(pszPSNR));
     870           0 :         if (sConfig.target_PSNR < 0)
     871             :         {
     872           0 :             CPLError(CE_Failure, CPLE_IllegalArg,
     873             :                      "PSNR=%s is not a legal value.", pszPSNR);
     874           0 :             return nullptr;
     875             :         }
     876             :     }
     877             : 
     878         116 :     FETCH_AND_SET_OPTION_INT("METHOD", method, 0, 6);
     879         116 :     FETCH_AND_SET_OPTION_INT("SEGMENTS", segments, 1, 4);
     880         116 :     FETCH_AND_SET_OPTION_INT("SNS_STRENGTH", sns_strength, 0, 100);
     881         116 :     FETCH_AND_SET_OPTION_INT("FILTER_STRENGTH", filter_strength, 0, 100);
     882         116 :     FETCH_AND_SET_OPTION_INT("FILTER_SHARPNESS", filter_sharpness, 0, 7);
     883         116 :     FETCH_AND_SET_OPTION_INT("FILTER_TYPE", filter_type, 0, 1);
     884         116 :     FETCH_AND_SET_OPTION_INT("AUTOFILTER", autofilter, 0, 1);
     885         116 :     FETCH_AND_SET_OPTION_INT("PASS", pass, 1, 10);
     886         116 :     FETCH_AND_SET_OPTION_INT("PREPROCESSING", preprocessing, 0, 1);
     887         116 :     FETCH_AND_SET_OPTION_INT("PARTITIONS", partitions, 0, 3);
     888             : #if WEBP_ENCODER_ABI_VERSION >= 0x0002
     889         116 :     FETCH_AND_SET_OPTION_INT("PARTITION_LIMIT", partition_limit, 0, 100);
     890             : #endif
     891             : #if WEBP_ENCODER_ABI_VERSION >= 0x0100
     892         116 :     sConfig.lossless = bLossless;
     893         116 :     if (sConfig.lossless)
     894           9 :         sPicture.use_argb = 1;
     895             : #endif
     896             : #if WEBP_ENCODER_ABI_VERSION >= 0x0209
     897         116 :     FETCH_AND_SET_OPTION_INT("EXACT", exact, 0, 1);
     898             : #endif
     899             : 
     900         116 :     if (!WebPValidateConfig(&sConfig))
     901             :     {
     902           0 :         CPLError(CE_Failure, CPLE_AppDefined, "WebPValidateConfig() failed");
     903           0 :         return nullptr;
     904             :     }
     905             : 
     906             :     /* -------------------------------------------------------------------- */
     907             :     /*      Allocate memory                                                 */
     908             :     /* -------------------------------------------------------------------- */
     909             :     GByte *pabyBuffer =
     910         116 :         reinterpret_cast<GByte *>(VSI_MALLOC3_VERBOSE(nBands, nXSize, nYSize));
     911         116 :     if (pabyBuffer == nullptr)
     912             :     {
     913           0 :         return nullptr;
     914             :     }
     915             : 
     916             :     /* -------------------------------------------------------------------- */
     917             :     /*      Create the dataset.                                             */
     918             :     /* -------------------------------------------------------------------- */
     919         116 :     VSILFILE *fpImage = VSIFOpenL(pszFilename, "wb");
     920         116 :     if (fpImage == nullptr)
     921             :     {
     922           3 :         CPLError(CE_Failure, CPLE_OpenFailed,
     923             :                  "Unable to create WEBP file %s.\n", pszFilename);
     924           3 :         VSIFree(pabyBuffer);
     925           3 :         return nullptr;
     926             :     }
     927             : 
     928             :     WebPUserData sUserData;
     929         113 :     sUserData.fp = fpImage;
     930         113 :     sUserData.pfnProgress = pfnProgress ? pfnProgress : GDALDummyProgress;
     931         113 :     sUserData.pProgressData = pProgressData;
     932             : 
     933             :     /* -------------------------------------------------------------------- */
     934             :     /*      WEBP library settings                                           */
     935             :     /* -------------------------------------------------------------------- */
     936             : 
     937         113 :     sPicture.width = nXSize;
     938         113 :     sPicture.height = nYSize;
     939         113 :     sPicture.writer = WEBPDatasetWriter;
     940         113 :     sPicture.custom_ptr = &sUserData;
     941             : #if WEBP_ENCODER_ABI_VERSION >= 0x0100
     942         113 :     sPicture.progress_hook = WEBPDatasetProgressHook;
     943             : #endif
     944         113 :     if (!WebPPictureAlloc(&sPicture))
     945             :     {
     946           0 :         CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureAlloc() failed");
     947           0 :         VSIFree(pabyBuffer);
     948           0 :         VSIFCloseL(fpImage);
     949           0 :         return nullptr;
     950             :     }
     951             : 
     952             :     /* -------------------------------------------------------------------- */
     953             :     /*      Acquire source imagery.                                         */
     954             :     /* -------------------------------------------------------------------- */
     955             :     CPLErr eErr =
     956         226 :         poSrcDS->RasterIO(GF_Read, 0, 0, nXSize, nYSize, pabyBuffer, nXSize,
     957             :                           nYSize, GDT_Byte, nBands, nullptr, nBands,
     958         113 :                           static_cast<GSpacing>(nBands) * nXSize, 1, nullptr);
     959             : 
     960             : /* -------------------------------------------------------------------- */
     961             : /*      Import and write to file                                        */
     962             : /* -------------------------------------------------------------------- */
     963             : #if WEBP_ENCODER_ABI_VERSION >= 0x0100
     964         113 :     if (eErr == CE_None && nBands == 4)
     965             :     {
     966          82 :         if (!WebPPictureImportRGBA(&sPicture, pabyBuffer, nBands * nXSize))
     967             :         {
     968           0 :             CPLError(CE_Failure, CPLE_AppDefined,
     969             :                      "WebPPictureImportRGBA() failed");
     970           0 :             eErr = CE_Failure;
     971             :         }
     972             :     }
     973             :     else
     974             : #endif
     975          62 :         if (eErr == CE_None &&
     976          31 :             !WebPPictureImportRGB(&sPicture, pabyBuffer, nBands * nXSize))
     977             :     {
     978           0 :         CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureImportRGB() failed");
     979           0 :         eErr = CE_Failure;
     980             :     }
     981             : 
     982         113 :     if (eErr == CE_None && !WebPEncode(&sConfig, &sPicture))
     983             :     {
     984             : #if WEBP_ENCODER_ABI_VERSION >= 0x0100
     985          10 :         const char *pszErrorMsg = nullptr;
     986          10 :         switch (sPicture.error_code)
     987             :         {
     988           0 :             case VP8_ENC_ERROR_OUT_OF_MEMORY:
     989           0 :                 pszErrorMsg = "Out of memory";
     990           0 :                 break;
     991           0 :             case VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY:
     992           0 :                 pszErrorMsg = "Out of memory while flushing bits";
     993           0 :                 break;
     994           0 :             case VP8_ENC_ERROR_NULL_PARAMETER:
     995           0 :                 pszErrorMsg = "A pointer parameter is NULL";
     996           0 :                 break;
     997           0 :             case VP8_ENC_ERROR_INVALID_CONFIGURATION:
     998           0 :                 pszErrorMsg = "Configuration is invalid";
     999           0 :                 break;
    1000           0 :             case VP8_ENC_ERROR_BAD_DIMENSION:
    1001           0 :                 pszErrorMsg = "Picture has invalid width/height";
    1002           0 :                 break;
    1003           0 :             case VP8_ENC_ERROR_PARTITION0_OVERFLOW:
    1004           0 :                 pszErrorMsg = "Partition is bigger than 512k. Try using less "
    1005             :                               "SEGMENTS, or increase PARTITION_LIMIT value";
    1006           0 :                 break;
    1007           0 :             case VP8_ENC_ERROR_PARTITION_OVERFLOW:
    1008           0 :                 pszErrorMsg = "Partition is bigger than 16M";
    1009           0 :                 break;
    1010           5 :             case VP8_ENC_ERROR_BAD_WRITE:
    1011           5 :                 pszErrorMsg = "Error while flushing bytes";
    1012           5 :                 break;
    1013           0 :             case VP8_ENC_ERROR_FILE_TOO_BIG:
    1014           0 :                 pszErrorMsg = "File is bigger than 4G";
    1015           0 :                 break;
    1016           0 :             case VP8_ENC_ERROR_USER_ABORT:
    1017           0 :                 pszErrorMsg = "User interrupted";
    1018           0 :                 break;
    1019           5 :             default:
    1020           5 :                 CPLError(CE_Failure, CPLE_AppDefined,
    1021             :                          "WebPEncode returned an unknown error code: %d",
    1022           5 :                          sPicture.error_code);
    1023           5 :                 pszErrorMsg = "Unknown WebP error type.";
    1024           5 :                 break;
    1025             :         }
    1026          10 :         CPLError(CE_Failure, CPLE_AppDefined, "WebPEncode() failed : %s",
    1027             :                  pszErrorMsg);
    1028             : #else
    1029             :         CPLError(CE_Failure, CPLE_AppDefined, "WebPEncode() failed");
    1030             : #endif
    1031          10 :         eErr = CE_Failure;
    1032             :     }
    1033             : 
    1034             :     /* -------------------------------------------------------------------- */
    1035             :     /*      Cleanup and close.                                              */
    1036             :     /* -------------------------------------------------------------------- */
    1037         113 :     CPLFree(pabyBuffer);
    1038             : 
    1039         113 :     WebPPictureFree(&sPicture);
    1040             : 
    1041         113 :     VSIFCloseL(fpImage);
    1042             : 
    1043         113 :     if (pfnProgress)
    1044         113 :         pfnProgress(1.0, "", pProgressData);
    1045             : 
    1046         113 :     if (eErr != CE_None)
    1047             :     {
    1048          10 :         VSIUnlink(pszFilename);
    1049          10 :         return nullptr;
    1050             :     }
    1051             : 
    1052             :     /* -------------------------------------------------------------------- */
    1053             :     /*      Re-open dataset, and copy any auxiliary pam information.        */
    1054             :     /* -------------------------------------------------------------------- */
    1055         206 :     GDALOpenInfo oOpenInfo(pszFilename, GA_ReadOnly);
    1056             : 
    1057             :     /* If writing to stdout, we can't reopen it, so return */
    1058             :     /* a fake dataset to make the caller happy */
    1059         103 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    1060         103 :     auto poDS = WEBPDataset::OpenPAM(&oOpenInfo);
    1061         103 :     CPLPopErrorHandler();
    1062         103 :     if (poDS)
    1063             :     {
    1064         103 :         poDS->CloneInfo(poSrcDS, GCIF_PAM_DEFAULT);
    1065         103 :         return poDS;
    1066             :     }
    1067             : 
    1068           0 :     return nullptr;
    1069             : }
    1070             : 
    1071             : /************************************************************************/
    1072             : /*                         GDALRegister_WEBP()                          */
    1073             : /************************************************************************/
    1074             : 
    1075          11 : void GDALRegister_WEBP()
    1076             : 
    1077             : {
    1078          11 :     if (GDALGetDriverByName(DRIVER_NAME) != nullptr)
    1079           0 :         return;
    1080             : 
    1081          11 :     GDALDriver *poDriver = new GDALDriver();
    1082          11 :     WEBPDriverSetCommonMetadata(poDriver);
    1083             : 
    1084          11 :     poDriver->pfnOpen = WEBPDataset::Open;
    1085          11 :     poDriver->pfnCreateCopy = WEBPDataset::CreateCopy;
    1086             : 
    1087          11 :     GetGDALDriverManager()->RegisterDriver(poDriver);
    1088             : }

Generated by: LCOV version 1.14