From bcc37563819fd4e8e952a07e6ea262def1d3976d Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Tue, 17 Dec 2024 17:32:32 +0100
Subject: [PATCH 01/40] /vsicurl?: accept header.<key>=<value> to specify HTTP
 request headers

Fixes #11503
---
 autotest/gcore/vsicurl.py                | 24 ++++++++++++++++++++++++
 doc/source/user/virtual_file_systems.rst |  1 +
 port/cpl_vsil_curl.cpp                   | 11 +++++++++++
 3 files changed, 36 insertions(+)

diff --git a/autotest/gcore/vsicurl.py b/autotest/gcore/vsicurl.py
index 2bc0f2f2b4b4..43c7de4bb761 100755
--- a/autotest/gcore/vsicurl.py
+++ b/autotest/gcore/vsicurl.py
@@ -1609,3 +1609,27 @@ def test_vsicurl_VSICURL_QUERY_STRING(server, filename, query_string):
             assert statres.size == 3
         finally:
             gdal.SetPathSpecificOption(full_filename, "VSICURL_QUERY_STRING", None)
+
+
+###############################################################################
+# Test /vsicurl?header.foo=bar&
+
+
+@gdaltest.enable_exceptions()
+def test_vsicurl_header_option(server):
+
+    gdal.VSICurlClearCache()
+
+    handler = webserver.SequentialHandler()
+    handler.add(
+        "HEAD",
+        "/test_vsicurl_header_option.bin",
+        200,
+        {"Content-Length": "3"},
+        expected_headers={"foo": "bar", "Accept": "application/json"},
+    )
+
+    with webserver.install_http_handler(handler):
+        full_filename = f"/vsicurl?header.foo=bar&header.Accept=application%2Fjson&url=http%3A%2F%2Flocalhost%3A{server.port}%2Ftest_vsicurl_header_option.bin"
+        statres = gdal.VSIStatL(full_filename)
+        assert statres.size == 3
diff --git a/doc/source/user/virtual_file_systems.rst b/doc/source/user/virtual_file_systems.rst
index 1b1eb0526dd2..ddacadfc5b0c 100644
--- a/doc/source/user/virtual_file_systems.rst
+++ b/doc/source/user/virtual_file_systems.rst
@@ -387,6 +387,7 @@ Starting with GDAL 2.3, options can be passed in the filename with the following
 - referer=value: HTTP Referer header
 - cookie=value: HTTP Cookie header
 - header_file=value: Filename that contains one or several "Header: Value" lines
+- header.<key>=<value>: HTTP request header of name <key> and value <value>. (GDAL >= 3.11). e.g. ``header.Accept=application%2Fjson``
 - unsafessl=yes/no
 - low_speed_time=value
 - low_speed_limit=value
diff --git a/port/cpl_vsil_curl.cpp b/port/cpl_vsil_curl.cpp
index e259b4078aa0..9ea17cabf2c0 100644
--- a/port/cpl_vsil_curl.cpp
+++ b/port/cpl_vsil_curl.cpp
@@ -352,6 +352,7 @@ static std::string VSICurlGetURLFromFilename(
         }
 
         std::string osURL;
+        std::string osHeaders;
         for (int i = 0; papszTokens[i]; i++)
         {
             char *pszKey = nullptr;
@@ -433,6 +434,13 @@ static std::string VSICurlGetURLFromFilename(
                         *ppszPlanetaryComputerCollection = CPLStrdup(pszValue);
                     }
                 }
+                else if (STARTS_WITH(pszKey, "header."))
+                {
+                    osHeaders += (pszKey + strlen("header."));
+                    osHeaders += ':';
+                    osHeaders += pszValue;
+                    osHeaders += "\r\n";
+                }
                 else
                 {
                     CPLError(CE_Warning, CPLE_NotSupported,
@@ -442,6 +450,9 @@ static std::string VSICurlGetURLFromFilename(
             CPLFree(pszKey);
         }
 
+        if (paosHTTPOptions && !osHeaders.empty())
+            paosHTTPOptions->SetNameValue("HEADERS", osHeaders.c_str());
+
         CSLDestroy(papszTokens);
         if (osURL.empty())
         {

From e4fe405de90d81a9f9b1facf8c83b14f5486e600 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Wed, 18 Dec 2024 21:26:42 +0100
Subject: [PATCH 02/40] GeoJSON: add a FOREIGN_MEMBERS=AUTO/ALL/NONE/STAC open
 option

```
-  .. oo:: FOREIGN_MEMBERS
      :choices: AUTO, ALL, NONE, STAC
      :default: AUTO
      :since: 3.11.0

      Whether and how foreign members at the feature level should be
      processed as OGR fields:

      - ``AUTO`` mode behaves like ``STAC`` mode if a ``stac_version`` member is found at
        the Feature level, otherwise it behaves as ``NONE`` mode.

      - In ``ALL`` mode, all foreign members at the feature level are added.
        Whether to recursively explore nested objects and produce flatten OGR attributes
        or not is decided by the ``FLATTEN_NESTED_ATTRIBUTES`` open option.

      - In ``NONE`` mode, no foreign members at the feature level are added.

      - ``STAC`` mode (Spatio-Temporal Asset Catalog) behaves the same as ``ALL``,
        except content under the ``assets`` member is by default flattened
        as ``assets.{asset_name}.{asset_property}`` fields.
```
---
 autotest/ogr/data/geojson/stac_item.json      | 109 ++++++++++++
 autotest/ogr/ogr_geojson.py                   |  36 ++++
 autotest/ogr/ogr_miramon_vector.py            |   7 +-
 doc/source/drivers/vector/geojson.rst         |  21 +++
 .../geojson/ogrgeojsondatasource.cpp          |  23 +++
 ogr/ogrsf_frmts/geojson/ogrgeojsondriver.cpp  |   8 +
 ogr/ogrsf_frmts/geojson/ogrgeojsonreader.cpp  | 165 ++++++++++++++++++
 ogr/ogrsf_frmts/geojson/ogrgeojsonreader.h    |  16 ++
 8 files changed, 384 insertions(+), 1 deletion(-)
 create mode 100644 autotest/ogr/data/geojson/stac_item.json

diff --git a/autotest/ogr/data/geojson/stac_item.json b/autotest/ogr/data/geojson/stac_item.json
new file mode 100644
index 000000000000..05821ff9c8c7
--- /dev/null
+++ b/autotest/ogr/data/geojson/stac_item.json
@@ -0,0 +1,109 @@
+{
+  "type": "Feature",
+  "stac_version": "1.0.0",
+  "stac_extensions": [
+    "https://stac-extensions.github.io/projection/v1.0.0/schema.json",
+  ],
+  "id": "my_id",
+  "description": "Landsat Collection 2 Level-2 Surface Reflectance Product",
+  "bbox": [
+    -155.80483200278817,
+    17.736060531368373,
+    -153.68026753986817,
+    19.82593799656933
+  ],
+  "geometry": {
+    "type": "Polygon",
+    "coordinates": [
+      [
+        [
+          -155.41188228421524,
+          19.82593799656933
+        ],
+        [
+          -155.80483200278817,
+          18.09429339392015
+        ],
+        [
+          -154.0866457786547,
+          17.736060531368373
+        ],
+        [
+          -153.68026753986817,
+          19.470851166420736
+        ],
+        [
+          -155.41188228421524,
+          19.82593799656933
+        ]
+      ]
+    ]
+  },
+  "properties": {
+    "datetime": "2024-12-16T20:42:39.252121Z",
+    "eo:cloud_cover": 58.93,
+    "view:sun_azimuth": 150.92260609,
+    "view:sun_elevation": 42.2078599,
+    "platform": "LANDSAT_9",
+    "instruments": [
+      "OLI",
+      "TIRS"
+    ],
+    "view:off_nadir": 0,
+    "landsat:cloud_cover_land": 43.14,
+    "landsat:wrs_type": "2",
+    "landsat:wrs_path": "062",
+    "landsat:wrs_row": "047",
+    "landsat:scene_id": "LC90620472024351LGN00",
+    "landsat:collection_category": "A1",
+    "landsat:collection_number": "02",
+    "landsat:correction": "L2SP",
+    "accuracy:geometric_x_bias": 0,
+    "accuracy:geometric_y_bias": 0,
+    "accuracy:geometric_x_stddev": 5.048,
+    "accuracy:geometric_y_stddev": 4.77,
+    "accuracy:geometric_rmse": 6.946,
+    "proj:epsg": null,
+    "proj:shape": [
+      7701,
+      7571
+    ],
+    "proj:transform": [
+      30,
+      0,
+      124185,
+      0,
+      -30,
+      1862415
+    ],
+    "proj:wkt2": "PROJCS[\"AEA WGS84\",GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]],PROJECTION[\"Albers_Conic_Equal_Area\"],PARAMETER[\"latitude_of_center\",3],PARAMETER[\"longitude_of_center\",-157],PARAMETER[\"standard_parallel_1\",8],PARAMETER[\"standard_parallel_2\",18],PARAMETER[\"false_easting\",0],PARAMETER[\"false_northing\",0],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH]]",
+    "card4l:specification": "SR",
+    "card4l:specification_version": "5.0",
+    "created": "2024-12-17T13:13:26.984Z",
+    "updated": "2024-12-18T04:59:46.657Z"
+  },
+  "assets": {
+    "thumbnail": {
+      "title": "Thumbnail image",
+      "type": "image/jpeg",
+      "roles": [
+        "thumbnail"
+      ],
+      "href": "https://exmaple.com/thumb_small.jpeg",
+      "alternate": {
+        "s3": {
+          "storage:platform": "AWS",
+          "storage:requester_pays": true,
+          "href": "s3://example/thumb_small.jpeg"
+        }
+      }
+    }
+  },
+  "links": [
+    {
+      "rel": "self",
+      "href": "https://example.com/items/my_id"
+    }
+  ],
+  "collection": "landsat-c2l2alb-sr"
+}
diff --git a/autotest/ogr/ogr_geojson.py b/autotest/ogr/ogr_geojson.py
index 61e25654c9a9..ee83ba27c291 100755
--- a/autotest/ogr/ogr_geojson.py
+++ b/autotest/ogr/ogr_geojson.py
@@ -5784,3 +5784,39 @@ def test_ogr_geojson_schema_override(
                 assert (
                     gdal.GetLastErrorMsg().find(expected_warning) != -1
                 ), f"Warning {expected_warning} not found, got {gdal.GetLastErrorMsg()} instead"
+
+
+###############################################################################
+# Test FOREIGN_MEMBERS open option
+
+
+@pytest.mark.parametrize(
+    "foreign_members_option", [None, "AUTO", "ALL", "NONE", "STAC"]
+)
+def test_ogr_geojson_foreign_members(foreign_members_option):
+
+    open_options = {}
+    if foreign_members_option:
+        open_options["FOREIGN_MEMBERS"] = foreign_members_option
+    ds = gdal.OpenEx(
+        "data/geojson/stac_item.json", gdal.OF_VECTOR, open_options=open_options
+    )
+    lyr = ds.GetLayer(0)
+    f = lyr.GetNextFeature()
+    if foreign_members_option is None or foreign_members_option in ("AUTO", "STAC"):
+        assert lyr.GetLayerDefn().GetFieldCount() == 39
+        assert f["stac_version"] == "1.0.0"
+        assert f["assets.thumbnail.title"] == "Thumbnail image"
+        assert json.loads(f["assets.thumbnail.alternate"]) == {
+            "s3": {
+                "storage:platform": "AWS",
+                "storage:requester_pays": True,
+                "href": "s3://example/thumb_small.jpeg",
+            }
+        }
+    elif foreign_members_option == "ALL":
+        assert lyr.GetLayerDefn().GetFieldCount() == 35
+        assert f["stac_version"] == "1.0.0"
+        assert f["assets"] != ""
+    else:
+        assert lyr.GetLayerDefn().GetFieldCount() == 29
diff --git a/autotest/ogr/ogr_miramon_vector.py b/autotest/ogr/ogr_miramon_vector.py
index 3cfebb9b3ba6..ecf4a647c9bb 100644
--- a/autotest/ogr/ogr_miramon_vector.py
+++ b/autotest/ogr/ogr_miramon_vector.py
@@ -1437,9 +1437,14 @@ def test_ogr_miramon_create_field_after_feature(tmp_path):
 def test_ogr_miramon_json_import_not_failing(tmp_vsimem):
 
     out_filename = str(tmp_vsimem / "out/json_layer_to_mm.pol")
+    src_ds = gdal.OpenEx(
+        "data/miramon_inputs/LT05_L2SP_038037_20120505_20200820_02_T1_ST_stac_minimal.json",
+        gdal.OF_VECTOR,
+        open_options=["FOREIGN_MEMBERS=NONE"],
+    )
     gdal.VectorTranslate(
         out_filename,
-        "data/miramon_inputs/LT05_L2SP_038037_20120505_20200820_02_T1_ST_stac_minimal.json",
+        src_ds,
         format="MiraMonVector",
     )
 
diff --git a/doc/source/drivers/vector/geojson.rst b/doc/source/drivers/vector/geojson.rst
index 4bc519abb7d6..dab99b5ec820 100644
--- a/doc/source/drivers/vector/geojson.rst
+++ b/doc/source/drivers/vector/geojson.rst
@@ -239,6 +239,27 @@ This driver supports the following open options:
       Can also be set with the :config:`OGR_GEOJSON_DATE_AS_STRING`
       configuration option.
 
+-  .. oo:: FOREIGN_MEMBERS
+      :choices: AUTO, ALL, NONE, STAC
+      :default: AUTO
+      :since: 3.11.0
+
+      Whether and how foreign members at the feature level should be processed
+      as OGR fields:
+
+      - ``AUTO`` mode behaves like ``STAC`` mode if a ``stac_version`` member is found at
+        the Feature level, otherwise it behaves as ``NONE`` mode.
+
+      - In ``ALL`` mode, all foreign members at the feature level are added.
+        Whether to recursively explore nested objects and produce flatten OGR attributes
+        or not is decided by the ``FLATTEN_NESTED_ATTRIBUTES`` open option.
+
+      - In ``NONE`` mode, no foreign members at the feature level are added.
+
+      - ``STAC`` mode (Spatio-Temporal Asset Catalog) behaves the same as ``ALL``,
+        except content under the ``assets`` member is by default flattened
+        as ``assets.{asset_name}.{asset_property}`` fields.
+
 -  .. oo:: OGR_SCHEMA
       :choices: <filename>|<json string>
       :since: 3.11.0
diff --git a/ogr/ogrsf_frmts/geojson/ogrgeojsondatasource.cpp b/ogr/ogrsf_frmts/geojson/ogrgeojsondatasource.cpp
index 123b83b7bef2..7fe16f97b864 100644
--- a/ogr/ogrsf_frmts/geojson/ogrgeojsondatasource.cpp
+++ b/ogr/ogrsf_frmts/geojson/ogrgeojsondatasource.cpp
@@ -1225,6 +1225,29 @@ void OGRGeoJSONDataSource::SetOptionsOnReader(GDALOpenInfo *poOpenInfo,
     poReader->SetDateAsString(CPLTestBool(CSLFetchNameValueDef(
         poOpenInfo->papszOpenOptions, "DATE_AS_STRING",
         CPLGetConfigOption("OGR_GEOJSON_DATE_AS_STRING", "NO"))));
+
+    const char *pszForeignMembers = CSLFetchNameValueDef(
+        poOpenInfo->papszOpenOptions, "FOREIGN_MEMBERS", "AUTO");
+    if (EQUAL(pszForeignMembers, "AUTO"))
+    {
+        poReader->SetForeignMemberProcessing(
+            OGRGeoJSONBaseReader::ForeignMemberProcessing::AUTO);
+    }
+    else if (EQUAL(pszForeignMembers, "ALL"))
+    {
+        poReader->SetForeignMemberProcessing(
+            OGRGeoJSONBaseReader::ForeignMemberProcessing::ALL);
+    }
+    else if (EQUAL(pszForeignMembers, "NONE"))
+    {
+        poReader->SetForeignMemberProcessing(
+            OGRGeoJSONBaseReader::ForeignMemberProcessing::NONE);
+    }
+    else if (EQUAL(pszForeignMembers, "STAC"))
+    {
+        poReader->SetForeignMemberProcessing(
+            OGRGeoJSONBaseReader::ForeignMemberProcessing::STAC);
+    }
 }
 
 /************************************************************************/
diff --git a/ogr/ogrsf_frmts/geojson/ogrgeojsondriver.cpp b/ogr/ogrsf_frmts/geojson/ogrgeojsondriver.cpp
index 93755c74f981..1b993844a311 100644
--- a/ogr/ogrsf_frmts/geojson/ogrgeojsondriver.cpp
+++ b/ogr/ogrsf_frmts/geojson/ogrgeojsondriver.cpp
@@ -709,6 +709,14 @@ void RegisterOGRGeoJSON()
         "  <Option name='DATE_AS_STRING' type='boolean' description='Whether "
         "to expose date/time/date-time content using dedicated OGR "
         "date/time/date-time types or as a OGR String' default='NO'/>"
+        "  <Option name='FOREIGN_MEMBERS' type='string-select' "
+        "description='Whether and how foreign members at the feature level "
+        "should be processed as OGR fields' default='AUTO'>"
+        "    <Value>AUTO</Value>"
+        "    <Value>ALL</Value>"
+        "    <Value>NONE</Value>"
+        "    <Value>STAC</Value>"
+        "  </Option>"
         "  <Option name='OGR_SCHEMA' type='string' description='"
         "Partially or totally overrides the auto-detected schema to use for "
         "creating the layer. "
diff --git a/ogr/ogrsf_frmts/geojson/ogrgeojsonreader.cpp b/ogr/ogrsf_frmts/geojson/ogrgeojsonreader.cpp
index 7a01b7bce2bc..fddf907519f1 100644
--- a/ogr/ogrsf_frmts/geojson/ogrgeojsonreader.cpp
+++ b/ogr/ogrsf_frmts/geojson/ogrgeojsonreader.cpp
@@ -1719,6 +1719,92 @@ bool OGRGeoJSONBaseReader::GenerateFeatureDefn(
             }
         }
 
+        // Whether/how we should deal with foreign members
+        if (eForeignMemberProcessing_ == ForeignMemberProcessing::AUTO)
+        {
+            if (CPL_json_object_object_get(poObj, "stac_version"))
+                eForeignMemberProcessing_ = ForeignMemberProcessing::STAC;
+            else
+                eForeignMemberProcessing_ = ForeignMemberProcessing::NONE;
+        }
+        if (eForeignMemberProcessing_ != ForeignMemberProcessing::NONE)
+        {
+            it.key = nullptr;
+            it.val = nullptr;
+            it.entry = nullptr;
+            json_object_object_foreachC(poObj, it)
+            {
+                if (eForeignMemberProcessing_ ==
+                        ForeignMemberProcessing::STAC &&
+                    strcmp(it.key, "assets") == 0 &&
+                    json_object_get_type(it.val) == json_type_object)
+                {
+                    json_object_iter it2;
+                    it2.key = nullptr;
+                    it2.val = nullptr;
+                    it2.entry = nullptr;
+                    json_object_object_foreachC(it.val, it2)
+                    {
+                        if (json_object_get_type(it2.val) == json_type_object)
+                        {
+                            json_object_iter it3;
+                            it3.key = nullptr;
+                            it3.val = nullptr;
+                            it3.entry = nullptr;
+                            json_object_object_foreachC(it2.val, it3)
+                            {
+                                anCurFieldIndices.clear();
+                                OGRGeoJSONReaderAddOrUpdateField(
+                                    anCurFieldIndices, oMapFieldNameToIdx,
+                                    apoFieldDefn,
+                                    std::string("assets.")
+                                        .append(it2.key)
+                                        .append(".")
+                                        .append(it3.key)
+                                        .c_str(),
+                                    it3.val, bFlattenNestedAttributes_,
+                                    chNestedAttributeSeparator_,
+                                    bArrayAsString_, bDateAsString_,
+                                    aoSetUndeterminedTypeFields_);
+                                for (int idx : anCurFieldIndices)
+                                {
+                                    dag.addNode(
+                                        idx, apoFieldDefn[idx]->GetNameRef());
+                                    if (nPrevFieldIdx != -1)
+                                    {
+                                        dag.addEdge(nPrevFieldIdx, idx);
+                                    }
+                                    nPrevFieldIdx = idx;
+                                }
+                            }
+                        }
+                    }
+                }
+                else if (strcmp(it.key, "type") != 0 &&
+                         strcmp(it.key, "id") != 0 &&
+                         strcmp(it.key, "geometry") != 0 &&
+                         strcmp(it.key, "bbox") != 0 &&
+                         strcmp(it.key, "properties") != 0)
+                {
+                    anCurFieldIndices.clear();
+                    OGRGeoJSONReaderAddOrUpdateField(
+                        anCurFieldIndices, oMapFieldNameToIdx, apoFieldDefn,
+                        it.key, it.val, bFlattenNestedAttributes_,
+                        chNestedAttributeSeparator_, bArrayAsString_,
+                        bDateAsString_, aoSetUndeterminedTypeFields_);
+                    for (int idx : anCurFieldIndices)
+                    {
+                        dag.addNode(idx, apoFieldDefn[idx]->GetNameRef());
+                        if (nPrevFieldIdx != -1)
+                        {
+                            dag.addEdge(nPrevFieldIdx, idx);
+                        }
+                        nPrevFieldIdx = idx;
+                    }
+                }
+            }
+        }
+
         bSuccess = true;  // SUCCESS
     }
     else if (nullptr != poObjPropsEntry &&
@@ -2127,6 +2213,85 @@ OGRFeature *OGRGeoJSONBaseReader::ReadFeature(OGRLayer *poLayer,
         }
     }
 
+    // Whether/how we should deal with foreign members
+    if (!bAttributesSkip_ &&
+        eForeignMemberProcessing_ != ForeignMemberProcessing::NONE)
+    {
+        json_object_iter it;
+        it.key = nullptr;
+        it.val = nullptr;
+        it.entry = nullptr;
+        json_object_object_foreachC(poObj, it)
+        {
+            if (eForeignMemberProcessing_ == ForeignMemberProcessing::STAC &&
+                strcmp(it.key, "assets") == 0 &&
+                json_object_get_type(it.val) == json_type_object)
+            {
+                json_object_iter it2;
+                it2.key = nullptr;
+                it2.val = nullptr;
+                it2.entry = nullptr;
+                json_object_object_foreachC(it.val, it2)
+                {
+                    if (json_object_get_type(it2.val) == json_type_object)
+                    {
+                        json_object_iter it3;
+                        it3.key = nullptr;
+                        it3.val = nullptr;
+                        it3.entry = nullptr;
+                        json_object_object_foreachC(it2.val, it3)
+                        {
+                            const std::string osFieldName =
+                                std::string("assets.")
+                                    .append(it2.key)
+                                    .append(".")
+                                    .append(it3.key)
+                                    .c_str();
+                            const int nField =
+                                poFDefn->GetFieldIndexCaseSensitive(
+                                    osFieldName.c_str());
+                            if (nField < 0 && !(bFlattenNestedAttributes_ &&
+                                                it3.val != nullptr &&
+                                                json_object_get_type(it3.val) ==
+                                                    json_type_object))
+                            {
+                                CPLDebug("GeoJSON", "Cannot find field %s",
+                                         osFieldName.c_str());
+                            }
+                            else
+                            {
+                                OGRGeoJSONReaderSetField(
+                                    poLayer, poFeature, nField,
+                                    osFieldName.c_str(), it3.val,
+                                    bFlattenNestedAttributes_,
+                                    chNestedAttributeSeparator_);
+                            }
+                        }
+                    }
+                }
+            }
+            else if (strcmp(it.key, "type") != 0 && strcmp(it.key, "id") != 0 &&
+                     strcmp(it.key, "geometry") != 0 &&
+                     strcmp(it.key, "bbox") != 0 &&
+                     strcmp(it.key, "properties") != 0)
+            {
+                const int nField = poFDefn->GetFieldIndexCaseSensitive(it.key);
+                if (nField < 0 &&
+                    !(bFlattenNestedAttributes_ && it.val != nullptr &&
+                      json_object_get_type(it.val) == json_type_object))
+                {
+                    CPLDebug("GeoJSON", "Cannot find field %s", it.key);
+                }
+                else
+                {
+                    OGRGeoJSONReaderSetField(poLayer, poFeature, nField, it.key,
+                                             it.val, bFlattenNestedAttributes_,
+                                             chNestedAttributeSeparator_);
+                }
+            }
+        }
+    }
+
     if (!bAttributesSkip_ && nullptr == poObjProps)
     {
         json_object_iter it;
diff --git a/ogr/ogrsf_frmts/geojson/ogrgeojsonreader.h b/ogr/ogrsf_frmts/geojson/ogrgeojsonreader.h
index 17d52af17d1a..da0a690b5540 100644
--- a/ogr/ogrsf_frmts/geojson/ogrgeojsonreader.h
+++ b/ogr/ogrsf_frmts/geojson/ogrgeojsonreader.h
@@ -60,6 +60,20 @@ class OGRGeoJSONBaseReader
     void SetArrayAsString(bool bArrayAsString);
     void SetDateAsString(bool bDateAsString);
 
+    enum class ForeignMemberProcessing
+    {
+        AUTO,
+        ALL,
+        NONE,
+        STAC,
+    };
+
+    void
+    SetForeignMemberProcessing(ForeignMemberProcessing eForeignMemberProcessing)
+    {
+        eForeignMemberProcessing_ = eForeignMemberProcessing;
+    }
+
     bool GenerateFeatureDefn(
         std::map<std::string, int> &oMapFieldNameToIdx,
         std::vector<std::unique_ptr<OGRFieldDefn>> &apoFieldDefn,
@@ -84,6 +98,8 @@ class OGRGeoJSONBaseReader
     bool bStoreNativeData_ = false;
     bool bArrayAsString_ = false;
     bool bDateAsString_ = false;
+    ForeignMemberProcessing eForeignMemberProcessing_ =
+        ForeignMemberProcessing::AUTO;
 
   private:
     std::set<int> aoSetUndeterminedTypeFields_;

From 967ebd57b7ff0e40bf48b3e60b13d9c419842a3b Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Sun, 22 Dec 2024 20:14:15 +0100
Subject: [PATCH 03/40] Doc: faq.rst: add a paragraph about 3D models

Fixes #11538
---
 doc/source/faq.rst | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/doc/source/faq.rst b/doc/source/faq.rst
index b079349bd59d..77697ae853bd 100644
--- a/doc/source/faq.rst
+++ b/doc/source/faq.rst
@@ -92,6 +92,15 @@ How do I add support for a new format?
 
 To some extent this is now covered by the :ref:`raster_driver_tut` and :ref:`vector_driver_tut`
 
+What about file formats for 3D models?
+++++++++++++++++++++++++++++++++++++++
+
+While some vector drivers in GDAL support 3D geometries (e.g. reading CityGML or
+AIXM through the GML driver, or 3D geometries in GeoPackage), 3-dimensional scenes or
+models formats (such as glTF, OBJ, 3DS, etc.) are out-of-scope for GDAL.
+Users may consider a library such as `ASSIMP (Open-Asset-Importer-Library) <https://github.com/assimp/assimp>`__
+for such formats.
+
 Is GDAL thread-safe ?
 +++++++++++++++++++++
 
@@ -108,3 +117,9 @@ How do I cite GDAL ?
 See `CITATION`_
 
 .. _`CITATION`: https://github.com/OSGeo/gdal/blob/master/CITATION
+
+
+.. below is an allow-list for spelling checker.
+
+.. spelling:word-list::
+    glTF

From f9be0194e682de103da9f41408520ba856dfa88f Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Mon, 16 Dec 2024 22:26:19 +0100
Subject: [PATCH 04/40] Add GTiff test files

---
 .../gtiff/byte_5_bands_LZW_predictor_2.tif    | Bin 0 -> 1036 bytes
 autotest/gcore/data/gtiff/byte_DEFLATE.tif    | Bin 0 -> 598 bytes
 .../gcore/data/gtiff/byte_DEFLATE_tiled.tif   | Bin 0 -> 736 bytes
 autotest/gcore/data/gtiff/byte_JPEG.tif       | Bin 0 -> 695 bytes
 autotest/gcore/data/gtiff/byte_JPEG_tiled.tif | Bin 0 -> 1033 bytes
 autotest/gcore/data/gtiff/byte_JXL.tif        | Bin 0 -> 778 bytes
 autotest/gcore/data/gtiff/byte_JXL_tiled.tif  | Bin 0 -> 984 bytes
 autotest/gcore/data/gtiff/byte_LERC.tif       | Bin 0 -> 875 bytes
 .../gcore/data/gtiff/byte_LERC_DEFLATE.tif    | Bin 0 -> 796 bytes
 .../data/gtiff/byte_LERC_DEFLATE_tiled.tif    | Bin 0 -> 1072 bytes
 autotest/gcore/data/gtiff/byte_LERC_ZSTD.tif  | Bin 0 -> 814 bytes
 .../gcore/data/gtiff/byte_LERC_ZSTD_tiled.tif | Bin 0 -> 1118 bytes
 autotest/gcore/data/gtiff/byte_LERC_tiled.tif | Bin 0 -> 1302 bytes
 autotest/gcore/data/gtiff/byte_LZMA.tif       | Bin 0 -> 758 bytes
 autotest/gcore/data/gtiff/byte_LZMA_tiled.tif | Bin 0 -> 1054 bytes
 autotest/gcore/data/gtiff/byte_LZW.tif        | Bin 0 -> 637 bytes
 .../gcore/data/gtiff/byte_LZW_predictor_2.tif | Bin 0 -> 695 bytes
 autotest/gcore/data/gtiff/byte_LZW_tiled.tif  | Bin 0 -> 816 bytes
 autotest/gcore/data/gtiff/byte_NONE.tif       | Bin 0 -> 758 bytes
 autotest/gcore/data/gtiff/byte_NONE_tiled.tif | Bin 0 -> 1418 bytes
 autotest/gcore/data/gtiff/byte_ZSTD.tif       | Bin 0 -> 588 bytes
 autotest/gcore/data/gtiff/byte_ZSTD_tiled.tif | Bin 0 -> 745 bytes
 .../data/gtiff/float32_LZW_predictor_2.tif    | Bin 0 -> 982 bytes
 .../data/gtiff/float32_LZW_predictor_3.tif    | Bin 0 -> 960 bytes
 .../data/gtiff/float64_LZW_predictor_2.tif    | Bin 0 -> 1099 bytes
 .../data/gtiff/float64_LZW_predictor_3.tif    | Bin 0 -> 1016 bytes
 .../gcore/data/gtiff/generate_test_files.sh   |  42 ++++++++++++++++++
 .../gcore/data/gtiff/rgbsmall_DEFLATE.tif     | Bin 0 -> 5722 bytes
 .../data/gtiff/rgbsmall_DEFLATE_separate.tif  | Bin 0 -> 5589 bytes
 .../data/gtiff/rgbsmall_DEFLATE_tiled.tif     | Bin 0 -> 6198 bytes
 .../gtiff/rgbsmall_DEFLATE_tiled_separate.tif | Bin 0 -> 6407 bytes
 autotest/gcore/data/gtiff/rgbsmall_JPEG.tif   | Bin 0 -> 2706 bytes
 .../data/gtiff/rgbsmall_JPEG_separate.tif     | Bin 0 -> 2916 bytes
 .../gcore/data/gtiff/rgbsmall_JPEG_tiled.tif  | Bin 0 -> 3739 bytes
 .../gtiff/rgbsmall_JPEG_tiled_separate.tif    | Bin 0 -> 5175 bytes
 .../gcore/data/gtiff/rgbsmall_JPEG_ycbcr.tif  | Bin 0 -> 1634 bytes
 autotest/gcore/data/gtiff/rgbsmall_JXL.tif    | Bin 0 -> 4007 bytes
 .../data/gtiff/rgbsmall_JXL_separate.tif      | Bin 0 -> 5228 bytes
 .../gcore/data/gtiff/rgbsmall_JXL_tiled.tif   | Bin 0 -> 4629 bytes
 .../gtiff/rgbsmall_JXL_tiled_separate.tif     | Bin 0 -> 6281 bytes
 autotest/gcore/data/gtiff/rgbsmall_LERC.tif   | Bin 0 -> 6110 bytes
 .../data/gtiff/rgbsmall_LERC_DEFLATE.tif      | Bin 0 -> 6005 bytes
 .../gtiff/rgbsmall_LERC_DEFLATE_separate.tif  | Bin 0 -> 6422 bytes
 .../gtiff/rgbsmall_LERC_DEFLATE_tiled.tif     | Bin 0 -> 7554 bytes
 .../rgbsmall_LERC_DEFLATE_tiled_separate.tif  | Bin 0 -> 8359 bytes
 .../gcore/data/gtiff/rgbsmall_LERC_ZSTD.tif   | Bin 0 -> 5989 bytes
 .../gtiff/rgbsmall_LERC_ZSTD_separate.tif     | Bin 0 -> 6430 bytes
 .../data/gtiff/rgbsmall_LERC_ZSTD_tiled.tif   | Bin 0 -> 7579 bytes
 .../rgbsmall_LERC_ZSTD_tiled_separate.tif     | Bin 0 -> 8618 bytes
 .../data/gtiff/rgbsmall_LERC_separate.tif     | Bin 0 -> 6679 bytes
 .../gcore/data/gtiff/rgbsmall_LERC_tiled.tif  | Bin 0 -> 8426 bytes
 .../gtiff/rgbsmall_LERC_tiled_separate.tif    | Bin 0 -> 9706 bytes
 autotest/gcore/data/gtiff/rgbsmall_LZMA.tif   | Bin 0 -> 5138 bytes
 .../data/gtiff/rgbsmall_LZMA_separate.tif     | Bin 0 -> 5712 bytes
 .../gcore/data/gtiff/rgbsmall_LZMA_tiled.tif  | Bin 0 -> 6110 bytes
 .../gtiff/rgbsmall_LZMA_tiled_separate.tif    | Bin 0 -> 7850 bytes
 autotest/gcore/data/gtiff/rgbsmall_LZW.tif    | Bin 0 -> 7107 bytes
 .../data/gtiff/rgbsmall_LZW_separate.tif      | Bin 0 -> 6846 bytes
 .../gcore/data/gtiff/rgbsmall_LZW_tiled.tif   | Bin 0 -> 7303 bytes
 .../gtiff/rgbsmall_LZW_tiled_separate.tif     | Bin 0 -> 7449 bytes
 autotest/gcore/data/gtiff/rgbsmall_NONE.tif   | Bin 0 -> 7878 bytes
 .../data/gtiff/rgbsmall_NONE_separate.tif     | Bin 0 -> 7896 bytes
 .../gcore/data/gtiff/rgbsmall_NONE_tiled.tif  | Bin 0 -> 12726 bytes
 .../gtiff/rgbsmall_NONE_tiled_separate.tif    | Bin 0 -> 12822 bytes
 autotest/gcore/data/gtiff/rgbsmall_WEBP.tif   | Bin 0 -> 4178 bytes
 .../gcore/data/gtiff/rgbsmall_WEBP_tiled.tif  | Bin 0 -> 5112 bytes
 autotest/gcore/data/gtiff/rgbsmall_ZSTD.tif   | Bin 0 -> 5873 bytes
 .../data/gtiff/rgbsmall_ZSTD_separate.tif     | Bin 0 -> 5609 bytes
 .../gcore/data/gtiff/rgbsmall_ZSTD_tiled.tif  | Bin 0 -> 6305 bytes
 .../gtiff/rgbsmall_ZSTD_tiled_separate.tif    | Bin 0 -> 6587 bytes
 .../gtiff/rgbsmall_byte_LZW_predictor_2.tif   | Bin 0 -> 6016 bytes
 .../gtiff/rgbsmall_uint16_LZW_predictor_2.tif | Bin 0 -> 7306 bytes
 .../gtiff/rgbsmall_uint32_LZW_predictor_2.tif | Bin 0 -> 9261 bytes
 .../gtiff/rgbsmall_uint64_LZW_predictor_2.tif | Bin 0 -> 11953 bytes
 ...an_full_greyalpha_byte_LZW_predictor_2.tif | Bin 0 -> 15525 bytes
 ..._full_greyalpha_uint16_LZW_predictor_2.tif | Bin 0 -> 20550 bytes
 ..._full_greyalpha_uint32_LZW_predictor_2.tif | Bin 0 -> 27155 bytes
 ..._full_greyalpha_uint64_LZW_predictor_2.tif | Bin 0 -> 35115 bytes
 .../stefan_full_rgba_LZW_predictor_2.tif      | Bin 0 -> 30723 bytes
 .../data/gtiff/uint16_LZW_predictor_2.tif     | Bin 0 -> 802 bytes
 .../data/gtiff/uint32_LZW_predictor_2.tif     | Bin 0 -> 912 bytes
 .../data/gtiff/uint64_LZW_predictor_2.tif     | Bin 0 -> 1025 bytes
 82 files changed, 42 insertions(+)
 create mode 100644 autotest/gcore/data/gtiff/byte_5_bands_LZW_predictor_2.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_DEFLATE.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_DEFLATE_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_JPEG.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_JPEG_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_JXL.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_JXL_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_LERC.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_LERC_DEFLATE.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_LERC_DEFLATE_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_LERC_ZSTD.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_LERC_ZSTD_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_LERC_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_LZMA.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_LZMA_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_LZW.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_LZW_predictor_2.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_LZW_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_NONE.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_NONE_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_ZSTD.tif
 create mode 100644 autotest/gcore/data/gtiff/byte_ZSTD_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/float32_LZW_predictor_2.tif
 create mode 100644 autotest/gcore/data/gtiff/float32_LZW_predictor_3.tif
 create mode 100644 autotest/gcore/data/gtiff/float64_LZW_predictor_2.tif
 create mode 100644 autotest/gcore/data/gtiff/float64_LZW_predictor_3.tif
 create mode 100755 autotest/gcore/data/gtiff/generate_test_files.sh
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_DEFLATE.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_DEFLATE_separate.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_DEFLATE_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_DEFLATE_tiled_separate.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_JPEG.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_JPEG_separate.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_JPEG_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_JPEG_tiled_separate.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_JPEG_ycbcr.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_JXL.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_JXL_separate.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_JXL_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_JXL_tiled_separate.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_LERC.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_LERC_DEFLATE.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_LERC_DEFLATE_separate.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_LERC_DEFLATE_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_LERC_DEFLATE_tiled_separate.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_LERC_ZSTD.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_LERC_ZSTD_separate.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_LERC_ZSTD_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_LERC_ZSTD_tiled_separate.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_LERC_separate.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_LERC_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_LERC_tiled_separate.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_LZMA.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_LZMA_separate.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_LZMA_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_LZMA_tiled_separate.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_LZW.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_LZW_separate.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_LZW_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_LZW_tiled_separate.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_NONE.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_NONE_separate.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_NONE_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_NONE_tiled_separate.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_WEBP.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_WEBP_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_ZSTD.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_ZSTD_separate.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_ZSTD_tiled.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_ZSTD_tiled_separate.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_byte_LZW_predictor_2.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_uint16_LZW_predictor_2.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_uint32_LZW_predictor_2.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_uint64_LZW_predictor_2.tif
 create mode 100644 autotest/gcore/data/gtiff/stefan_full_greyalpha_byte_LZW_predictor_2.tif
 create mode 100644 autotest/gcore/data/gtiff/stefan_full_greyalpha_uint16_LZW_predictor_2.tif
 create mode 100644 autotest/gcore/data/gtiff/stefan_full_greyalpha_uint32_LZW_predictor_2.tif
 create mode 100644 autotest/gcore/data/gtiff/stefan_full_greyalpha_uint64_LZW_predictor_2.tif
 create mode 100644 autotest/gcore/data/gtiff/stefan_full_rgba_LZW_predictor_2.tif
 create mode 100644 autotest/gcore/data/gtiff/uint16_LZW_predictor_2.tif
 create mode 100644 autotest/gcore/data/gtiff/uint32_LZW_predictor_2.tif
 create mode 100644 autotest/gcore/data/gtiff/uint64_LZW_predictor_2.tif

diff --git a/autotest/gcore/data/gtiff/byte_5_bands_LZW_predictor_2.tif b/autotest/gcore/data/gtiff/byte_5_bands_LZW_predictor_2.tif
new file mode 100644
index 0000000000000000000000000000000000000000..201c6733dc1939bafac8859380aecf46453a777f
GIT binary patch
literal 1036
zcmebD)MDUZU|<krU|?isU<9&6fS3`9%>-n#0>y3tF*8&g#Ak!DL3#ukS-^T{0Xd>b
zYQ&&ykeT98HAPGe3^GW1ZJ}(SFhdZK%>tyK0C6yo4YKDA5c4(jFfaq@Z$RAC!o$D@
z5(C<`zMYvt0m!xkvNyIfF~|VfbwD-<aKIsi5A+orLPY!=P-&Pt?6ku(DMygZnRz~7
z8pH;f$iTqP0CF_gbSTZlvawwhB+s$2osB`1fejeMj0}Cs3_Kt@Jc9*HYbyIWx)_-&
z=qrSV_$pN8=cOtb8v50M1#1`@q%KWRj&OX)#=#W#VS)D^WxfvQLkb*A0t9|^A4}%%
zSW~9;oacl}kfchVyWC_ag^xRSEM2cBa$26<B;~?$p?0r?50x6J`xNJIKj!mFR;=UP
zybBpZ3tB2KNG#u_A!-pDCdu9JzS8&OX}MjNvwhPUC9Y2W7*>5|rK#18Hs9neeh)6+
z_~LqBZf4}-0PCkGA7<=vTT}Sj^*L|V{>a=W$vU&sw%d;cwC|ZEv~c>0EBb-E*F4%R
zd;H{*Ma#BL_FbACdeA82%Xb5bwd*~iRp0&!R9&0&GAR4Yx3|gHukVQZIgQWCE4ql&
z^Rm35)lu0JiJjA3W~Dav-p-7Oxbl6y?AuV&(9D*7{mwJv6{0ld+v+E7JYr~czUMK&
z#QyAGt*Ygp|NNVJT3eHG$J$>Co3;iRsT|UJ@i}De%Kp>FESpcfN||+-<FnMK!#!Cu
zHf>*@<aBm@fYXK5>rW+z^c$^NY}d7xZ?V{pr2!A;NgR7tWA{r*C;D8vtM-(*F8vGA
z>WU5ApT%}tbL`HWsFNgEtLZgqX03|n@*`=hm$_yv)fZi9QY>To;!9JDRk!v(P5nz-
zmTWq$ImKe_sYOEDz6$kjvYPA5bI6ussqdwmd@5(6d?l^3cJJwR=3IP7;P`79j~czR
z!5zJx!cA6N_ZUmgJ33|2Ri~hJr?s}*y1wP|<el|}sjOdTwf3uyfK@>$x6HCXZM(Ll
zq)X|FNpH}M$*#G~?;SNvgB<#Wn`LMDsc%iGS?u^arL5=jg(oVf*JPy%tlZl1HqyZR
zUGSt$m(TfLjarqxsajRj=as@twZJ9ktD9I?Osy5$ROR%$QOK#<U$g7h@q*Jle;lUj
Htl$6u4gyL@

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_DEFLATE.tif b/autotest/gcore/data/gtiff/byte_DEFLATE.tif
new file mode 100644
index 0000000000000000000000000000000000000000..fa9ec63a6c329b06394bace1ba8482e43ea281c4
GIT binary patch
literal 598
zcmebD)MDUZU|<knU|?isU<9&6fS3`9%>-qGR52s5*`REY9zjMHu-+mdM-)k149W(X
zDGpWh1jv>_Qe%t64n|`0HS;hq1J#}b;-(fJ1~wr542ajaGczavX)&N(8{3%}WPt22
zkR#y0&jG@O(QpZ@42Ne@jv$FM^L)TGh|LK04Lbt^3xo}HI#`T}Wn;T2NS<S3I~#*2
z0~;_<7#aGM8F)Z+cm@lY)>QU$bTKkl&{qfz@l~kG&r4M>H1w+h3)V1H%u$`7Sma{J
z<NW@*a*LD{R~MI*R2v&x-Hr_<>w|Bcx|?D&b7RU+RZmAP&zEae$_|G=UNDL0VpPrz
z=Wwn?wGK+rOJ;MvcTv~L@|R#R<Da_n?Df5OGrl`oFMB%o{`S=(lUMF6$vnQ}RAf<&
z!90Wh5B(lmF|$vG20ol<)a?39;nu?$IozeOkDgBv-1uqPb)Vg`i(U5RS!rqIf8Ap}
zXPpM~jkIlRp8iOU*`IpAX}P&9Gk?Ft3D-S&R~y3;c0OaNKUe3I5LG9+V_RS2`}6Ok
cmu1eqY<lM8^P79W*O}PcaZjwT@INLD0R10{i~s-t

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_DEFLATE_tiled.tif b/autotest/gcore/data/gtiff/byte_DEFLATE_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..c93c3dac502d24d68e11561f88f5bedf39ad0589
GIT binary patch
literal 736
zcmebD)MDUZU|<krU|?isU<9&6fS3`9%>-qGR52s5*`REY9#JH=3=-QGiR}bs3jozS
zBe7i=Sr}M=Vvm5>6(|m3-vZ)bB)xpiJPgc0u}?tU)WXBS2Bf)w7O!t-W>5gKt$^%}
z?Mw_ZKz0?#K|nB-!H>ZmC_4?v*Jfg1s088zKnwwX4yZI#7zgF>Ov(`?b!MIqm<F*K
z!J);@0CF&h4fF<>W@6dcE(((8*x1g-Aj-f73^+!HK4k_T5FMVu0;V;U{TyA4%oX$%
zLPLBNs`B$v6$}miYQTau3>9-^`xV7l3^|<NTZ&0aN=kRS^sRj(81`<jS&m?>iSG}G
zWp}qtG|I@RxG~|B_O_|(GF_iXbUFGoGVjk;TX}Kf$DQSEllOm#e)QdMd$#eO>ls)3
zuCrtx{^33$=H>3y+7}faSy*!{4JzNP4&am(mydaJ$CE8Yl1Iq&rsGtV@brMzKb}{F
zrx;|N+tbx68N~XFJ$_$Je#M;7o`s?Z9C)0p({oc)gt~ir&Ty&kc1yRCF8I$le@0!{
zk{M?`mJ~Y94tD<kf7^9Mv*Y6T4*&I>Ie*Dl#qXi>jO1@i$UZy#`ak#XAMz6_=3G6v
zkg>smgEioJam#8KrHQ|kC;rf$=uyIY-EdX*o$7G+DT$rBf}#bBWRvP<RS5juV{T#-
zIF)gJ;v|_Rj`hc%*##d{T2V2_`&?dTq63q6b=9PaKW|>Wc~#@jqbE6Si7X5|Cb8!O
E0C=LfKmY&$

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_JPEG.tif b/autotest/gcore/data/gtiff/byte_JPEG.tif
new file mode 100644
index 0000000000000000000000000000000000000000..8176b1bed6a0978ead61345d76073ea7d31c2817
GIT binary patch
literal 695
zcmebD)MDUZU|<knU|?isU<9&6fS3`9%>-qGR53%@>_9dflnv4&$jAcLy9dY-MG_Z-
zvO#8wL)H8SvSpCe1S7Gd8QB>;f%4~on6H_Kff-0k0L^S_;bC9{vJHUj_3g|I3P5%O
zkiD^;i9rU)UI1i+!2cWnZ!<VEaImqlv$1lpv$Jz@a&Ym8@bYkT^GFH_^NYwz$;-(~
z$;c?E=&36x=_t#{Xqap27#NzEn8>SJ+FBUd=oy<B{l5t@j=|3X!hq3GVH}jhGbu-q
z)R}ocU>d|`1cwVSyjUP?U?70Sm{>Npi-P1iHny`dh%&GNgO`z^Pnm%SM2BavfN4!-
zKSviMa|L~c&=6mRs{FiE1w%u>8n9pu$hQX=xH*6^Cc?-l$ngINgE%OPK-R(m6Eh1N
zP(n+9fr*icg@u(BCd0@i$jrhZWaucY7+A=vlsIvth*Q$R5C3m5a4-UmuxBVey8V)&
zS83pb)K8K(dTaj`N@`CD(J{7A(69Y^$w4Cfj_m>$(UUq0PsA+Id3&a$`Skk8L+kmO
zHtU7|sT7?b@y@>bLFCjHwXijZk{0wVnRwFW?UH%3I1YA&%yoRc<V7mu^E>|;a(neV
zqXYKs^y2ji4rJ^yoHa=)%Jcax^VdB`k8@pZ=V~=L{w`D9q1<l2#LRUv+YazD{dC{Z
I*#G|~0Amh@8UO$Q

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_JPEG_tiled.tif b/autotest/gcore/data/gtiff/byte_JPEG_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..4be2fad690a6002d302f326583ed33676891ca50
GIT binary patch
literal 1033
zcmebD)MDUZU|<krU|?isU<9&6fS3`9%>-qGR53%@>_9dflnv4&io}*dVmm?E0zfs+
zNNg8I76ule*driz1&V{%w}3bpNpCbGJA)@s>=O|4HS;hq18EzeWlb$S3~WGl2#~$L
zotZ%a$Zi3$H?}h|$N<?#fNT($$I!#j&rrbd0LZUnVqo9`8ZZ-x|KIq3o57iZgN==y
zjg^C)ot=}DgNsLmmxr61M^Z?bUqn_)UQSj@Mn*wJPhCMtM_EQj!(3Cxz|h3RL|)y}
z*22g}&)CH1|4oQB41Nv}28@OZ<DeX#NjZX~&dl=x(;zk@INX6@3JeAi8yGlXnu%p&
zyC_JWV`DoTgD3+VFbWtM`ji=XKy-Kp3z*ha_H%SGGFQ-72o3R7sLIbvRWLO4s{sqv
zfP8y^ft!OtfI)zfQIO&P5e9KkG=i)}048P@poF>r0}~??3kxW6A%KxdkXeX<#n4e$
zM6pmQFfnQ3#)JQFF>o*f_1iOSOV&MQ=v5l{Ao_vvMyWr4A4_UytcZwt(6IOWbx($b
zb8@U{(ebx0toe1k@b^B^nGsG=S7-Qy2xh931X^dRpLUe^e-qPnV!*VA>N-XSCaB{W
zm{~aya*Rw2%z`Y!ijILoqK3gCg%c-V{D5$r+=Xur9qN-JohR&8(JeZX>D;#Kn&F;h
z#qx)08oZ{w;{6rgxQe;I__xM7)l#9q+49)jA_5F$RKNyt2_rKT3o9#Jijj#~kb#9&
z*wIPR(AYFEv9NI?l1m&rqYZ0|+C*;TDlv75q@EPinpE-IZC}RGW1*|sf_YnIPfe<1
zUitOc(!B5bQ!eT_ub6*3I3AmGutXdqGb_+V%Akk?r*D{(fMLTTD6C{?<QUjEani<%
hh;TWd<vi^IV?*@fg#leRzvr9%Rx6gX<?#Q16976!%4`4t

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_JXL.tif b/autotest/gcore/data/gtiff/byte_JXL.tif
new file mode 100644
index 0000000000000000000000000000000000000000..ff444755fc22d756a995b67f45f7ab95d2a7822e
GIT binary patch
literal 778
zcmebD)MDUZU|<knU|?isU<9&6fS3`9%>-qGR53%@L5CR_*r05X9zjMHuwDfw1_n_i
zaWN<xWTrS&%_|^V21!jY5}U7?hk+R=UjsC>sfCAu4alAXWUp^$W>5gKj{w;l+nE?-
zfNU0^T@6c^7}f#V=YSXlY}{QOeSA|(5>paO679GY6l^?8QgapZ5_3~+m7M*31A<(G
zgFXHI;)7hnT!Vr=ojiR!Ln4(FQu1>XGxKbfJbfMAUE_m8f<m1`LW5kD?0o!#gMEN{
zZ1h0}p_}Lx;S=xb=H?$1g2xC`m|h!wRM$bA%;4t$VZdmpFb>M$nUo_)>dZVJFb!fe
zg2SF27$gujFrdL=Oe`DQMM3f$8{63!L>btCQOL;9r_8_uqQf&-z_g~apQDSBxq`kz
zXo#;uReoNof}x>b4Op;-;Xl_50Ra(nCJq)xh5}}94HL0>+NvrdQ&<$7B%5=jg*luj
zOf!&hbNS1pz_{i@2tz=Rej`Hz5HfVI%#2!nZLV4Ddal{>+0CmT{JPD1_~@EuRRN~Y
zM@+P;gbg=kZ?KxUo_W!;uWFmRzi|AwImuJvxIo1x)87Al^Y%o+YJ>Px_vjY!4LtwV
z4AjfFd&(SB*2$3WYWS6D!R&Kqmj;j3WA{W2*1HQHMRdNKWx$i^ctKCJXzk`4;baq~
zJ|i(jUJYr>kL=+k0`(&76JH!_ZN9qT$lWW#Av`HuO~v^uPrZG!{n=~br3yie{hR>h
CGOYIi

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_JXL_tiled.tif b/autotest/gcore/data/gtiff/byte_JXL_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..7263c74e78eadd03306126cedbd167cd29d425bc
GIT binary patch
literal 984
zcmebD)MDUZU|<krU|?isU<9&6fS3`9%>-qGR53%@L5CR_*r05X9#JH=3=-Q3$`$~s
zaYkahFtRYP0L2~wu`5s<#J&Z@!AN@fnt2$Qfnp1Q7Bsc+Ft7pHJAmx<?aT}cK=unD
zdt*BjgA9<Z!NkDOu!M<W9gzJAh(TZ>Lo`DIg9U>NQ0^%ZI{*z^0K_)#E{;CFsU?Xi
zi6x14TnY*{o+YWd3VDgSskTba{=NZ0uED{c{(kX6u3@f0!JbZ@KAs_wN(w3Yxrv#1
zwo0D9j_$7U!68AR&LN>eu1a=3{=vaMKs`44AcN3N^osC_cXe~~4+_C!gegp~jXtXD
zAYNhcbAT{lG*lP|<?u|(5hQhHo)4G?u^GW}%gz7_Y7iS30brVmWn;T2NS<S3I~#*2
z0~;`!85#PN8F)Z+cm@lY)>QU$bTKkl&{qfz@l~kG&r4M>H1w+h3)V3F=W=!kxWmE0
z!pIQ7<So%H$`Hkr$PvG1CxZzClM5Te`u`@3H|rS~kJd9ZW@Iuvh+Ms)!kHt-Mkn&C
z?*U7uN5a=kjrRIBZebGP{K@iSLnhnS&Z#+DLk_T5aGlnXe3Sj`j)>-*=o>v6n^Jm(
z8D4E(_Su6ehHc3n_XWPUWU8GqD~o<?O}zF%_>{ih!#LGVtnZ8i4Wtj6G@t#;afOSU
z>4poE11%W6HB^qdIvs4`m=|CqCz-s5+kx5PmmGt`HCOImQjH9GrW`7<b1vPql?}ae
z?b)PG1@$>xrO7@a-`{Y2h&kxU^(X3Z!;LR>$xCilu54gH_PY<nXvc#r4Yv&4lzCRi
zUa9BHyvg{bjNN|1;u%V5tS*gbo^v<uG5B}B+rdf0R^;0951dUB`(CV2V%6kO`17`#
zg{NuqZAZ`61Q9`ThW+|)KQbdZeGLQD=`0DIpB}~b7~W%LV0_`cjcLbY6Q+g+hdoQ?
PUgEf4x#fkFuP+M#2=VvD

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_LERC.tif b/autotest/gcore/data/gtiff/byte_LERC.tif
new file mode 100644
index 0000000000000000000000000000000000000000..6fdc1343eed23cd9c0c591fdb6535d22384c9b44
GIT binary patch
literal 875
zcmebD)MDUZU|<krU|?isU<9&6fS3`9%>-qGR53%@?i~yaY*02xk02upSnm%YM-)k1
z49W(XDGpUr3{)e7q$U`N&DYGszzkFy0#wt~!o$D@Waj|c>)V+b6oBkGK=#IVCI%TG
z`wo!Zu!M=B2*`c}#Gj6`Ffak>TR;o~ED(yp#@)ry$2YYkF(t7i(T+<&!N#*BHCG`o
zF*ns#$=TmGAjma1*wf!HKFBr9H7MBA$<xO(BvMHsB|kSYGtXAZ)7R16H9j~bDAYM5
zG{{xS&c{DE*axV`MjvF59hZ$hstr(k{Tv_+7!4K1K{-5=as)}8ndbwhL2O2Fn6iVt
z0%8LL5G=;TvawwhB+s$2osB`1fejcnj0}Cs3_Kt@Jc9*HYbyIWx)_-&=qrSV_$pN8
z=cOtb8v50M1#1|5Qj3y}6hL8Q<}3XL6hGj22htOO;R=dtP&@$<6g;p8Ga7;%!1RNB
zFzxl9fe9SWK!si)2_W6FjT5W{m_mTG0U8EJ5l9ONvjTAf5C;Hp0TfRF(qQ{RG%{!a
zavFBdVPQ~^XqHeA5J&*>4fe**D>rxF@cR}gyWeS%U%U7F&D^lL_SnR{9h=^KO8qFZ
z-MYl<j6`#n*O}`N1rr$0bMF?LS#qQBdf~cD58tQ+99?ny`BN7q<@IrW)l08k{lB|R
zHYh76HTU|hZHA4pt0mv`-jVRxB`+ylsu4AXW#)+z)kx0AGZJ~1cM9dLW?OT>Qs|k2
u(fn&Fjj#9wJ6c0n0$AEy+Lmu(W{aIJ*(RYVP;xd>p@qTc&NhYzj#dDjMW&?y

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_LERC_DEFLATE.tif b/autotest/gcore/data/gtiff/byte_LERC_DEFLATE.tif
new file mode 100644
index 0000000000000000000000000000000000000000..3e38b0950fc7cd150fba4cd396e5a09c81f9a262
GIT binary patch
literal 796
zcmebD)MDUZU|<krU|?isU<9&6fS3`9%>-qGR53%@?i~yaY*02xk02upSnm%YM-)k1
z49W(XDGpVm0#qY|q$U`N&DYGszzkFy0#wt~!o$D@Waj|c>)V+b6oBkGK=#IVCI%TG
z`wo!Zu!M=B2*`c}#Gj6`Ffak>TR;o~EI<rY!eHa>;^^a>T9TNOSdwVRrJ!KrS(2Ko
zke8U7YOCbz?;8;08XWBD?-w8B8s-`l?CIp`;~5gEq>z%Io0yqrtK{kH=<XUH91;}j
z91<Gjs$}Qm9~|rh)MKL$GRTh0MjzD%kmW$&=K!YQG=ztXba*D^2$DN9&j(C{*o<KJ
zvxB_?VgmyZEXKsLv0W4-&#|$cjX{)w4Hz|y41LNBJRmweg9S`$D*HLQ7?~^RD};vl
zDpcj?r79R2`qh91YZxl#eD>7!G7CybOh_;Yo@}Shw8U|SV23&bC!a#>8IFg}2bil3
zt_nP1c=)V2bNzoF9|dCvuDuINPMi6ykTX*-b2!Z7<8X%Q=o*JP3`ZCpVi=AJJ9Jq{
z7&tO>yq|OU&;o^vItvvP7%pXOFt3Z-x$}41{p}Vv|N3?RxwZFx{<F5TTaT+fdwb){
zv*1_m6W?A_jZ0UVwR_LGn0k#F2P)=OZ@+P7l632J?(4BtKipIwyy&`pe*P{E&Gr4S
zSI1Soef9rt>L$lX%auE?=jR&d^u+4^T=u=M<-A^{=fj}h6`DH6{!>=C71_<3cw+aS
zV2ym!+q0ObIh_~jc@`g>S#wnV#zm<^LI*BAyR@xF*f{!4$w@O#*TzYkCvxfX*p+WH
Ov?&l_W2nqYmIVM)<IVX1

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_LERC_DEFLATE_tiled.tif b/autotest/gcore/data/gtiff/byte_LERC_DEFLATE_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..8e8ed7da9b06e258c6e564f950777da936e90a62
GIT binary patch
literal 1072
zcmebD)MDUZU|<kpU|?isU<9&6fS3`9%>-qGR53%@?i~yaY*02xk0=sb28rziWeWh+
zI3uxL7+DxtfMV}}*cB)aVm|}oU?jbK%{&auK(Pv-1x+nH3~WI51R#5TJ2Qg<kbMBi
z-q_B>AOmDGFflMREMa0O0y5cv;-8MPfP@(Sf#iVT977XB1%nTR3{dbD5a$35egecG
zdx6RsY}{QOeSA|(5>paO679GY6l^?8QgapZ5_3~+m7M*31A<(GgFXHI;)7hnT!Vr=
zojiR!Ln4(FQu1>XGxKbfJbfMAUE_m8f<m1`LW5kD?0o!#gMEN{Z1h0}*>TzEquKy+
z6cG41fGIc);o%}3o=G`^<j&0V0n;EhBiQ}yV6TAKz<>pdF|llH7X`_4Y;0#^5M^Kk
zMjs<XpE3gvhz`$S0n?hwevU3i<_h`>p&`BsRrz_T3WkP$HDJLShKf0#J$1dzf)WxF
z5)5WstMq2@Xf{x0Zh62E<kJ&iCt<UJJ(xF<FQLkjZAPEfsRKutt_rg*>0>PP=Chu_
z;wkO0k;#KqSYWe*p@$=*0J{TkK0{*X>{$-l!lH}5{pU=c{O{M(%i9|!|N3k@Z|?6(
z%h>t9XPp;&_IT&)bS?u4i~1R9%4Wd_*1Z3bd3gK0R>7~kr*Gd@l5;2jZS}6j)k(W&
zzVKSCCK?vTCb<5|`a|1Y(&TQQ*tq84;|q^&+wxAHuCl@Qf=^HhZ(%3{!xkU=iO9aG
zSX27Gm0<!~q8l5>LB=KL4*p2^a9|#zq|AvDhRX`BSC1AiYq+7Sd$QP}q_C{eY{omy
zJjRPRb&FRietLf3k#6?tZpV^O*HR4T_byy2u}FFMF4i@RckPlo<Db{K;?2pp+sxM@
zZCQQ9{XN-MYxgys*v!bVLtkSSiVHLp1XLN8IL?^J=v2V4a;^a=IMW^2_&>=W_)<S%
zmMC9S;K`duuj<+cKhufbUHX3K`~Sty_1-;rGe`Q?;t#hB|ISG3e>G)+3Y$)Y=!%)g
zxffdBII%P0%$BvQiptY}eF+j5FZt?|!=TZp!HR6}h3C4TL>Mk9oH@auXweX&*u&4p
z|3-4c!6p%QgS{e4(ps6_i^>X1z0Y5A$ZLChhNs&?Vo^lEl+A`485s_o;AH~<L{~RF

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_LERC_ZSTD.tif b/autotest/gcore/data/gtiff/byte_LERC_ZSTD.tif
new file mode 100644
index 0000000000000000000000000000000000000000..2745a5bd5553bd920c658667823995853c75d578
GIT binary patch
literal 814
zcmebD)MDUZU|<krU|?isU<9&6fS3`9%>-qGR53%@?i~yaY*02xk02upSnm%YM-)k1
z49W(XDGpU*22>-1q$U`N&DYGszzkFy0#wt~!o$D@Waj|c>)V+b6oBkGK=#IVCI%TG
z`wo!Zu!M=B2*`c}#Gj6`Ffak>TR;o~EI<t6+qk<p`uL`nB&H;mB-(K)DA;(Gq~<E*
zCFZ8uDmnZ61_ZeV2YdSa#Rs{DxdsJ$I(hndhD0hUq~zx&X6D%{dHOoKyT%8H1cf?>
zga)}P+4=Yf2m1i^*yw`{vg5MRN3{WDIS}|cfGIc);o%}3o=G`^<j&0V0n;EhBREXi
z!CnEefdL2>V`ACZE(((8*x1g-Aj-f7j2cFUK4k_T5FMVu0;V;U{TyA4%oX$%LPLBN
zs`B$v6$}miYQTau3>sVY|0WbOq;fK(2>7HHB^xP#!b@z$9Y1jV1KAUR;R}lMV#Wvd
z4M7eJ5AwbKGcd6*c(rWf1jUO1ICNQ9fy@LT4glhU2^<U!JLj-4C`dF*C<q7`?2VsS
zZtlL}_bpC#ztbYWcJKF_xnXndv59#*Hof_j`cY)Nb&1y*iRLb^GuIyqCNQ4o-Yqt>
z<VNB3!gZG(zEKG{y5jcpr!Gp$>*M;WmtMR2e|MQ|P*zTA?)6*S3>#xtOTOv7BjK}4
zUQ)PJBWeoE%o8Q5k(`fbB=Ror6v|u8w&sAP&@%<2`PWn$U-1ccw1%(*u(Y|fE#Jh<
z7CT+CO+rzi<ZPru3xm&{Z43_-rwS+(G?iJ${9tz5yKv2iKdGs^_nq7P`Kj;B{1j(X
LmjVMf%LR!5jzGE<

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_LERC_ZSTD_tiled.tif b/autotest/gcore/data/gtiff/byte_LERC_ZSTD_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..c3636d12e07caa6b0ecb5a3e280f7e80847f8211
GIT binary patch
literal 1118
zcmebD)MDUZU|<kpU|?isU<9&6fS3`9%>-qGR53%@?i~yaY*02xk0=sb28rziWeWh+
zI3uxL7+DxtfMV}}*cB)aVm|}oU?jbK%{&auK(Pv-1x+nH3~WI51R#5TJ2Qg<kbMBi
z-q_B>AOmDGFflMREMa0O0y5cv;-8MPfP@(Sf#iVTAww$=hBL?j1^)tZ6VPCGprs&t
zLF#PWT^xOUQ%e$45=#>8xD*s@JWEn@74i~uQ*D);{e1(1T!Vu>{r%#DT*F+0f<2u)
zeLO=Vl@wC)a}zW3Y?VBH9o=2ygF}KsokK!{T$Sv6{DXsifO>57K?d1z+32I%0CE%%
z_&I<nI1S<9A|0MdIfCTQ%<}=$AT}d7&e*|T0kMGr3l?Ky+1M@$lIPgi&c-0hzy^#y
zMut9R1|AR{p1}g9HI@AwU5v~X^c6xwd=;wl^HLQI4gG4sf;9{pTlN1YFfr_9V^HDt
zNi9k?QUHaQ!L-g>p!j42ryC~52lfqN4h#!2qK+~!u|xqSjsbB?4$w&q1`43SWhnp>
z0Syv2HJKP05*4EM{|RH0{`%$9w}6xS^F5xO`*}HCpZl867Utu*n`a6z7&w2JW+OIJ
zz^w21X~Vakg%S0;m$$ZbY}{|{d%B~0V!N5>N~0zfR#pZPujH@7w?t+h*~qc1!Q;^4
z+dU1Fmn5(~&`eTv4RKZA=Mc!S;J0RMo1&38U99!3P|KoqUh7R9oKueorUf}Ro{g0N
zc~IfpQ)Y%mM}=iKurpjc$tdORs6N$;^=wMn)OdZ#DJ&j}ziOlH_}f&n5A%xtbicdv
z=DzjI4O_3iI{otdytwrz>!xHeB^`83o*2?GAx5sJp*e*~AmUK~hu8`Sw!l6A*e)<_
zvKGjAon*OV)vYU^t77|O?%At7II{5FxygYw9EDdCmx3L!6X*yQHbfvl6cC6)1oF-Y
z_6!g59saLy5R6LBF0O9rnKEbT+O2!fegB_3cX0=2=iJa9h1ZVh$25CXrvxQ2urjQ0
z;PDDJaxNA#ZL6x>-I+eU)WwB~jf-K;BGHz$4AY;k5YWEPV6%fQ&91lU#x!nbup<gf
znHXA_5suL3E%HP-q7dka1t|_oS2%D$+^{r|n_)XJ>^K;rSlF0=32dpAoz}ZkrVRY+
N8fW@1R@nCR5C9Q59Krwq

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_LERC_tiled.tif b/autotest/gcore/data/gtiff/byte_LERC_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..3fc3978f3955d691e9243ad21bbb1c1d2ee8193f
GIT binary patch
literal 1302
zcmZ`%ZD>+q6h2<v%{B|G8Brr{RzK{In^678mZq0=hq|S1m4BAq$qI98y9=rtBy~$i
zGK!=aSdG^D_%T8%A|i^YMHK!Cf(l|0jGzx9`XGqvoL6hM)(g*lp7(sb=e*~=lC%tr
z05BUsrw1LXYJ{##b0tkt`jT!)1MnqHIhHbAQ>NFJv>9VOW!kGVfB|jq5hB`2k0U~5
zxib%#K##UvSYW?q0v`1d)R$6v5K!MnolkL4gBm!1<XH}SQ1WR1c+Ws4_(48goUQ=Z
zp&M$@xDXG0ix|eDRF{^s!Rz+<W4+P#Xm7N>QV^U{Z!95nMia5sR!@_^IVgrgQd6KU
zD7K2hkhE6vN#RXap}i{+-PXC<D*4?FVp}L2Z1IF!f}*wF*Axo*Fvn@9gX$}t_P;9>
z%R<0a6u-G-{tvmv=ex=E=#-B!X&rmBY3wSbaj?wB8S*I$`HlG$4;J9@`E<~~7)-<)
zwi+1Q76;s3$4bF2w1oY_p03WAP*)e&%Zz)$7weH70?nxQc;7R6LjsPMedvGSaKrXw
zgRwP?lC3VrgIgI#?g7W<jDZn!j3Tt{*fEg1wgds0JsE`(C}0Po89^&anD^9%C8I**
z*7sI^!RJpOzcfFvpI$d!`1ZKNUiHLxMSnkWdB6;{o)5>Ja|g^T`tLuidna{o+;`*r
zK`ouXwaWi6efVf<h2^4S|B{LdsBV-$&v{loa5rx}mt1#e=y@i2?CfTK%(i8b7#4+z
z3A|eN;x*l#P(Fde?>+LL2{4VH+uK}BQjn_Tvb51OIY+F-l{n*!q7lcnoJy=|1!mVq
zRE75PRhjL1(3E0ET-8{Hs;bN*YsJV+d?dq8P_vActjyw+NYT$v+~%d(9GU7i*D?Q}
z_oOpvjdi&g|D>1;u2~T|uBcijn;Ravdb9BLXX4~gdV1f<mW=Sm-7#v*EX@YDu!KpU
z3QRUNPGpB19%b(GLwk1L=<7JK)9alS4qRE|_8C3WRE>9I(tjHtY<ICUhl`CHi+vBT
SuYzlOIAer};jfZB$NvHp734qw

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_LZMA.tif b/autotest/gcore/data/gtiff/byte_LZMA.tif
new file mode 100644
index 0000000000000000000000000000000000000000..9ff97e933efd0d0a0d692e30292cdc4b7e70e96d
GIT binary patch
literal 758
zcmebD)MDUZU|`^9U|?isU<9&6fS3`9%>-qGR53%@xg87)Y*02xk02upSZ^ATBZ?$0
z24#cH6o;yr08}G`q$U`N&DYGszzkG-2#A|nco^7#^erG>-_FdS0HnEqdN;N+F~|Vf
zUO+Yi_&Gq>Fd89)jpgu6$`K@fW}Xk22C*5zK452HV1clK&IOAxv21J?1<7-4Y-eK-
zWncpa1S3PAG6N5Y4$oi#)0)bDjxI*#3i=A6A-)P#`FW`dhK7DMV8I%OzvfjDQ9v{P
z3*B@Ch9@I~BBNNP!jX3m82cH+V;M}F|LSe6-e>k)@80{z%ukFR3d)XMm-)lt?pf?}
zsk8Qa+EVwE`yN;Q;Cy=YafgQ5!k_*3R{g1cYEm}y!Qa&>?Uie)MLj}=-Xyp4-KkKn
zUX}cK=@Qe;{asJ4?q9aDe@1k1`3sISA7vMv(m(u+*{l5aQ`zgvUw3RVVlnjzDw!_o
z?`2uEs%`2~>7*_m9<z0+7lbqNB^MlU4^?GYKeNg@XtDJF(2hL;`Y(>Wap*Gs{(O&z
z)(i1lrQLTv`@8%0HD+&0d3(wD)a3_$E`j|oqBm?kzd=bhcdyP>r|d0ZJ%)`TaXkM&
z@XkMUA&k+H>xHr7W}YTaU)2Dm87ekOOxx2`uI^u%Qhn6Yx<6%ZaK?%QkDu1;?EPXR
zf3#OU&gK8^;>=ZUq5;pY8|eSJb2}{6%8FOVn5AjTYX{?xE#9I+yv6Nqt~Z{aVVPwU
uxis|ljkG;d%%?@N_8m+3-2e=42FBM+6MzYd(O95r1q0U~CXg6IWE21+kkY{b

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_LZMA_tiled.tif b/autotest/gcore/data/gtiff/byte_LZMA_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..1cafedcb89bd942cafb9c4967aed82914703dc6d
GIT binary patch
literal 1054
zcmebD)MDUZU|<knU|?isU<9&6fS3`9%>-qGR53%@xg87)Y*02xk0=sb28rziWdluT
za7JRgFtRYP0L88Wu`5s<#6Aba!AN@fnt2$Qfnv{qxT%GQfelFi1LF1V%nS-ZS`TRP
z#&#wK86Z0k<Om>8V4T6w!VtmG1>~<{VqkCr8gL9`2pIS|pwbW?F4Ezdlp{#)%sd}3
z4PrBbLx`OL<X{jR=nXK<#Imtn6eQ2Fv7L=Ulz|NxSd0vP$_zXpIy{2~OlvCpIl35`
zE9fhPhWIK}<>#d;7#jN3fCXz9{+d@sL;=nCFLcup80L%&ii~2F3P;{OVEE7QG?u}%
z`LEvA>V0O<_3piY%>2aIB5g;M|K$x=qJP{fogB7?HEYB4U9!br{$IR*UVm9;r2D?_
zSG{gsWVqHU_f_reMU{fE8>?FN;-io7{a@bF_p`jOHd`-2+*Ekm2l*qtb|)?#|9HqV
zJM_A%)zk+wzn7WJ5xQVFC+Xhz;QWa@9$)&Co6q~Ho;le0*Rey&4N@#wxApSBPuV>&
zZv6+F%8sVs$=v2l*+$oAoS1pf*GvDv##74~4OB}$eB5_=zWvIZUlwvs{`s?LN0>{n
z%+==5Pa>ZfZXCGvxn1qs#pg+t%xZFM51xqL@^GEJZx$$w85n;uHUQ)9<@Hjf6%1T|
zfJ`8WjKUW_39$^e`xy0`=V;g6J*^>o(5fWWb6&~!664u&hq@K6UcdL_oZ#2p8}I$R
zy*q$s%?aLLXV0Z-9Dfsd__EWX=X*rOOLbU|o)#0|JLghnios)dhX2QYM@`$n@wzIt
zWs7W0{KdQ3KY;Ek0Xd67_%WvkvF`GUWr*7&{(#}M>NZ8;e-mPPm-sB)ez^agsK~(v
z&y2^vIi_mwnG>({aoUpPUyB;~CAM`o%I&SVkv;9k?MqQs{EIbye)M8Vo@L&twCeyU
z6c`xez;19pYWI#<Hz>q17&iWww^@*1W#Q*>g4;gY%;|UT<{MKK!tZ#VNS2h?0y5VG
MY;OI_KzC$w0c58=y8r+H

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_LZW.tif b/autotest/gcore/data/gtiff/byte_LZW.tif
new file mode 100644
index 0000000000000000000000000000000000000000..1232be0405ead06ecb05b39545c108f11b1e5eeb
GIT binary patch
literal 637
zcmebD)MDUZU|<knU|?isU<9&6fS3`9%>-qGR53%@tUxv!lnv4&$jAcLTLk2YB8iJZ
z*&s8;p=!8+YGjbq*dnomk=T6AJPgc0edmC<sfCAu4M;x&;`Qy!3<^M63~0{Ab|wZH
zAUh1mMgTtt2pdKtWU#Ruo=G`^#Lvw00n;EhBiJ|W3=Av~Hqhx{F(#Ic?V=!gj*abX
z45AEdz(8SS=u>9k0ny<ZEMQtw+0W6%$Xr2RAvDBSp(;NwRl(5EuLdkw!_XjgKErvI
zAV*KLB5%P86OLzdyc`n(MK#Y#GTF|!Fu}sG*OIkG?$NO=DI(vwn`F)wEm@N1$~Ms_
zHPbU@8qb{OgMG!DZv}i?+BoZB=HXjkqt<%4q+i&fRd8J2$+$Ns%E?GjYNC_C)E1>}
zu69f1E>5b@S@GQ8aIH_l3l%<Yy|p*rURt%WS0dT+<ioHGnR%9+J;%;wdLQlDE3seh
z$u~>EGh4F5F02S`o~ty!ZtKORMXR?tO6s<{<qNLfc&;|WD|E?>pMhEPt@oTSxwup-
zsB=<x#@n)>D_y-|T?<WbJeFPWso|#^IQ4bso2f-^ej?jLv+w>p*BbG3RqUEJR;H-6
SNu1}Eu5t>trYtSn!2tj+9+t8I

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_LZW_predictor_2.tif b/autotest/gcore/data/gtiff/byte_LZW_predictor_2.tif
new file mode 100644
index 0000000000000000000000000000000000000000..85ed33ba67db88574d7ac21c6b1df0aac8a076c3
GIT binary patch
literal 695
zcmebD)MDUZU|<knU|?isU<9&6fS3`9%>-qGR53%@tUxv!lnv4&$jAcLTLk2YB8iJZ
z*&s8;p=w-#YGjbq*h1M%KsCWg;(X0K49q~Wb3okG!o$D@q@Mxt`gUdp1t2X3G-qQw
z6N3zp9R_40fS&_|4Wkh<*jNtFq#QxwXXg2UX%L$c>>G9l1{Me#=yb3c6U)YSQII^x
z#&$LaQ3f_(pfED@DKqeZ=<o~{Fs-TV=jdW&uAr|F8se)^m7kZYU})%90~V}dXplO@
zFulTsfun|jfv@0<k(fXYS3J8x_Z$Vu{GOQ?8yXldC{{Nm`hGkUB=Eh)jYY4Z`|blt
z2I~X-9ZrD{zRx_kRG`86fPi9llj1@Vg~W>-GY+lrD-4bhdd|S+%=`8AAu)#hQ%^qx
z9F{To(JVB1O}O(sp&x5bF&oVGPzgF$qpCP{X7auo!Sb_mB1w~W2vl#dJ}BUMfkEg#
zN8E$SCJBt|G_zaOH{5*27t73`sOVquXGhTalPoSe&s$0uKG+_b$0RvLEy5|@X;~5b
zp{?i6^JE?pDVlt+hGXWD=qGA_Zppo1NOIBr=shod?$*WHIuCjj?{Tibw90f^MXPsH
z{?!E!=k!JhaO^3bFB<mOeWf3V<&%KESPq6cpE5rDRI6C_jbnRev`kp1gX6qt%i|SB
dSC^?D{BU~9(p6%!6dg`G<S$w~iEqAw0stT_sB-`S

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_LZW_tiled.tif b/autotest/gcore/data/gtiff/byte_LZW_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..b43311f0e16ab8e4e271c7e5518ddce13d58fd21
GIT binary patch
literal 816
zcmebD)MDUZU|<krU|?isU<9&6fS3`9%>-qGR53%@tUxv!lnv4&io}*dV%s9IouF(1
zpn7K{whJQ*0}D{>5fHlq#X;;_Kpc#um#>+Jff*?F35c6oco^7#G#Aj~_3g|I3P83M
zkiD^;i9rU)t^zp-2sSaqGQ=?GGfV^WJ(w66mI5)*NGR}gfG}V*OdLDy@Jz}PBy(n-
z510nA8Ns2&&H!>Shz;}xm}X+x*e(i^=h)cJ#vsbT1`IexhCXEm9uOU#!2+f=mHixD
zjLa4E6+%ON6{_;{QWXph{c6C1H4F_>=QEsV33Bu_EAkesFkHvY<Rx=uxk(Dgw`3=W
z2OFC21YGNBn)k54Wl5SfTi>a~lO9n;{A`wI{4<?zO=HWBTOGR6qvw)1tDnT<HIcWB
z1SR?o2~6o+^5t94L`T1ZS0ZzsOHFY&lWrv{aja+UiG`t7d(wo(duCmlCX%$xrFw_^
zJ7J-VYooIF#I7xu*z@SUq3Mh#8&>SiGmN)9tNro!TA!^>Gp;_%3RzU-TG5r*Q}9HE
zr9tjo=8*+VyzDKG6FQuwiiG(YWX=|9w5UAmv0SLMp*c#>qPq9s!<@%4Z6a$MJsa3e
zSN3_UImtYllpOg^T+8-c>L+0-p<p#PsjDkahWylYnJjZ@^3A|ATkR(taA?pEU2!C7
z%Ci<-iE{;$CD$Bl@zV|Lx_nDWq*_(xO!}6jLXNf7`){6bjxzW*#Yr<{rAv~)x2;jj
zg*s0zy2>%7dDe5c4J_Yk?H2@OgjlJH^|~(!$_&|+YBtxlp`k(IY=(;h*x^%F97*g0
hI$Y{J$l=$D8(otFcRVSxm7m~|5@e||&4;0(0RW3a)QSKA

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_NONE.tif b/autotest/gcore/data/gtiff/byte_NONE.tif
new file mode 100644
index 0000000000000000000000000000000000000000..a4cbc947432c190b4c5815cbf3d54499392b807b
GIT binary patch
literal 758
zcmZutF>6#o5Z-rpoFN>F;2Dq<4^n9(v9V3SCc#{z5_s*R2m@M7=cLksYX-5{a<O~m
z60UgVH37SjAK(x0FIeg~?@saxXIbWB=9_Q6-IJ3iVJC!eFNA6wDxe3r)c}vS*jeK(
zcHVS=?^lz4_8l7YLH*$tyXM}O^9`K+0q4~K-~BQRV{or<KkF<^k$>V|F2|up-o@-{
zISTv0r@*(dINIQU`L^>vboA@dvDdG^zwEQ)s(-<q5GET8yM1jmSuN+@-&rlEVIHRV
zh$?(N2s6*;?<akJe6Tov@$7m1w0`sYtp4=z!`u4saB<NWF9M0Os;MgBC<*7pNQqlE
z5{WA4#mwLcD#j|{F%wf#5ey6C5GP_ZHM<xyOOjTUNVBX<Nr@BYSabA|8~Ra_nL?dG
z_a#NZaF#(!As;1n5q^|=iy|6P^UY?_B33FqpecBRhkK=jh82`#a}5@`p+X4XR#Nm%
zq;(-kMWbTL-yNZ@(O>{Hcq3~d-@q>3;>M!3DGOv6%VTttjqtjdwX99#1~n+)b8-g<
ka4V-UY*||vF2DcWD48T}+k~$qoUY3$=iI6PxCcl23r4iyN&o-=

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_NONE_tiled.tif b/autotest/gcore/data/gtiff/byte_NONE_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..b75bec93cdebedf1325a192cb976fad8d2e1dee7
GIT binary patch
literal 1418
zcmdT?v5FKy5Utr=)(aLfa1*&;;UW!`Gcmo>GdR&rRD?+zL1;LG%B+jDU}0&DDs0Rq
z9AtwDFEo=4{e=4kGxgQn9`po$z;#noue!Qkzp3ui(+9LiM0bd)F;zf!VO4=gJM6p0
zJM8<W1)djpzras-80_?{z$ev&CRqCgdyaL-TiENO_V$+<jj?tK`>ZpX!vBGNUyW%2
z{}3WJs}b!3pSd6()zw@hUXNfPSUY(?mPbQ>75(pfbb0UCb3ebm?7d^BC%Q#0xIb#=
zN0ZHJ?)kmVYD#mOqFEJvJ)oKUcONFbzkjeiK6(6P@o4e(&8x+yk7w@}hlk7ae({{5
zD61w_jhGr)qZl`wqDW9rCKW`9Rgh;>5flhxMz*Ngi<wzW8qs*swq|VD%bJ7mkJeIB
zFfq2l8Q4t{YLz1gC*xj%hz7(dg%m&yB@qdMFxL?ci>Vc;l9*7%b!;O>Yv70yaByUf
z!SD|fz@#DJpaA7HsA@=oMzO}Spp0=y2oNEh&3k-3ATnQL_fQcBF&a_EXn>Tl>UOYS
zTj4Svx-iT`beYF}4EX(j%e;58j8kk=8Kc94m@N$WxE|JDv?(>Lb>JHP2%0-|88;y>
z{4%n(zyEF(9XD+n!&B(GY&qvn4KD?wJo_f%fJa^GZtwuhIO1^)VjkXKnY)SjANyM5
AqW}N^

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_ZSTD.tif b/autotest/gcore/data/gtiff/byte_ZSTD.tif
new file mode 100644
index 0000000000000000000000000000000000000000..0a5af35305433f2457d18d7f44e6bc1dd90be2da
GIT binary patch
literal 588
zcmebD)MDUZU|<knU|?isU<9&6fS3`9%>-qGR53%@0f!kF*r05X9zjMHu-+mdM-)k1
z49W(XDGpV03&@s1Qe%t64n|`0HS;hq1J#}b;-(fJ1~wr542ajaGczavX)&N(8{3%}
zWPt22kR#y0&jG@O(QpZ@42Ne@jv$FM^L)TGh|LK04Lbt^3xo}HI#`T}Wn;T2NS<S3
zI~#*20~;_<7#aGM8F)Z+cm@lY)>QU$bTKkl&{qfz@l~kG&r4M>H1w+h3)V1bY}NnE
z5YfxVASPibxuB7OA@5JPl2)yi{+yFfnL1sV;$#2UdoijoXfS9o+!nP`{kf@v%RDCX
z+fBR2C*qg;+(_m68~e6}Y58pB8-MTVpWnSduCIEji<0vC718JXnzj0hr}8a7+_yXK
z#?})(4AK>0N&EQHj|r@>h(5}ZZJ~QoOG5mF%d*wZ7Z+Xmdtye$lePm_w$3`ZE?1iS
zMA)rTkCl<(%);Aqi{)Abl-m}*-qoXEGu76>;lPBB4HLQ;yzVMC|H$;^T9Lq|<lMk(
Tp&odMm6@S@b3=j3<<unrw~>1B

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/byte_ZSTD_tiled.tif b/autotest/gcore/data/gtiff/byte_ZSTD_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..fd8ad1d4538dd78c3aae1898df427245525f86d3
GIT binary patch
literal 745
zcmebD)MDUZU|<krU|?isU<9&6fS3`9%>-qGR53%@0f!kF*r05X9#JH=3=-QGiR}bs
z3jozSBe7i=Sr}M=Vvm5>6(|m3-vZ)bB)xpiJPgc0u}?tU)WXBS2Bf)w7O!t-W>5gK
zt$^%}?Mw_ZKz0?#K|s*S5X<1kpw2K2$d_kgV5kA&LqH4xeh#QKR2T>4@Jz}PBz0z<
z510nA8Ns2&&H!>Shz;}xm}X+x*e(i^=h)cJ#vsbT1`IexhCXEm9uOU#!2+f=mHixD
zjLa4E6+%ON6{_;{QWXph{c6C1H4GYC_5U(Nu(B|0Ixj1{0cho#D1l%RCda*T{70A=
zMA-cWxo4`d8cW<wV=-ZM5jv;R=elD4g=Gv20;GghG&MG?^qA@x(_{1JZf2C8ic8PY
zUCRyMdKQ}X9Y1X&HdDaB`NOo$GX)s7Fdxs==f381?&sxn{rMixK79)~$tL~vOVs{9
zVT_CnEX@f^AP!l|#9+c)T|8$BLrY8YoZ{@_?4IJ5?3OvzEiLD=*H#xNZ%r=Fu5PKW
zuFg(w>B(N(Q$3}4N^(n-zzP8g)vt^N$!`VrZM?_Gyk_H}m78*X47(nwEoLs_f*Agm
zkwJ)sSNH<s3a6vjPcg045}mawMB_IT!+(d{Rj1O^Qp=x+E9zC*inwf?Yr)9t`!qf6
zq@j%5Cvin!nD;XULQMI}z|fJL-O|Faw5KOIyE+@_sBB=&c*wXOa7-&oV$cNu2Q{Xf

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/float32_LZW_predictor_2.tif b/autotest/gcore/data/gtiff/float32_LZW_predictor_2.tif
new file mode 100644
index 0000000000000000000000000000000000000000..77527c94410bb6810f2c7a7542d4e15e264f1b7f
GIT binary patch
literal 982
zcmebD)MDUZU|<knU|?isU<9&6fS3`9%>-pD0L7W1Y*rwf4ax@T5oBZm>n#FuM3KbB
zplpzt;!rgyObiS%NNQ}MY@jehFqF*<Wb-xiFo5WDK-|>A!@vflp8@guc4h_zAT0*8
zYhybTgA9-z266-(_&GqBFd8m_mErJA$`K@SW}Xk22C*5zzF}uzV1clKP6vxIv21J?
z1<7-4Y-eK-Wncpa9V0`ZG6N5Y4$oi#)0)bDjxI*#3i=A6A-)P#`FW`dhK7DMV8I%O
z1_lP+BoPirCI;q(eCmHVY&klZ6!|-HoOCXAbuSd`5XsVE=wnd$pxzRaE8Mkn!2*sN
zE@$OwZjToKaAwm|YcX21nWNcB%dW*{(S{X&99u=Tom2x}xOlOOGzKi0TzO`ez^$&+
z4x$RoO~$Tm?oT!-v?v{8;1YOMDzV1td{jrc&bR0YrkAl@cOM_%vYjMo(HN#VK|yr|
zgG7s!(v}CTPP&PU?r%uoY1k)lap9T8-}kt&Y1tl*e8g9sm%&(lB7E_NU1yZ77(!j$
z#By_LrgFHrdhEyv;r8^u^g$u~0xQ$a(gVpA<|qHM8#9R<k~ECAUB)_Ltw*U~z!t@;
zqE}-VimqurC;0H@f#nyJYZR3$TWpt>{Y~={{yO9M>xo?IMm(Rlc{u+%p?hM5#9<}Y
zOIpf`0>S@&+i2f%+P&xe=3nb<G@E~Q7_8~;W3bKBp3`WfXTT7tp5gTF-2zAMB_CW3
zK7DAk3!Hpt@&dnKN1o0+vBIT=>xE;`(@okoK0B2bX7k)X@`1~qXQ3e1JL7E~B5l7N
zR<Dt0RQC{RYLtGldJTh#uTi4FBF+}C7K=$Y7!I1eKjN&sZCwy6^XaZlEFta}Lsl_J
zpID*NVr#6@X|Me5)V@Yn4iO)r4acj+Rv#0b^zO;QlOhcL>t63Z(RF-<P`I;#FVky-
z#SczpTTK%Y5||O9z{>9D|IxT(uf~GMyrBwiyR^j>{ARKI+tJzd&R=QKR5ONvjmbwE
z%@?pXFnCVznRM9fg|I~WqNSU(CLCvADfx3{+N5qzi{MS$y)Fl;Br&jUa1vBAJd>;(
U#~}9j&4i1Ala+Sw(bi%D06rWXrvLx|

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/float32_LZW_predictor_3.tif b/autotest/gcore/data/gtiff/float32_LZW_predictor_3.tif
new file mode 100644
index 0000000000000000000000000000000000000000..815acce744db4d6ab3a87e28dfd7704920152adb
GIT binary patch
literal 960
zcmebD)MDUZU|<knU|?isU<9&6fS3`9%>-pD0L7W1Y*rwf4ax@T5oBZm>n#FuM3KbB
zplpzt;!rhyObiS%NNQ}MY-XUEU?etQGY<nu>>Lm`weT>o0qJKzyuO{8K><jM0qxq@
z&cq-CWQTzq0SA5#5GIU<OJHR<Jd<(+Nt~JI1ExW2MzC+#85md~Y@pM@VoWR>+eJb0
z92?u&7(^M^fI-K|(5KA61ERw-SirQVvY(@ik-37tLTHGuLREfVs)C`RUkzBWhM_^A
zfkFHS3nP2;!Gs0uf8=;33oy@de88aikv)@pu>#wK#s_9K)`~)wD${(`Crwx|!6Iax
zEO#42NaBk(7wQfQ8?`X7HT-<S*Sw+YoTsZ;uf|lT)Crz3Qqmkj?2FE;w>-(Y#cwl*
z=>c;G!v_u<){tt|DeXM%Q7ThzXuCf6wEn2pG=b&@1-(QTmaFYgr~P%^eB$Mo9U*)Y
zhj^@%uHLY4uz4iD#qq2H!w!R6tnr_NVtCYU`fWKZpU=QN&qA*->``KCz`=(is!BSQ
zdlxWU&ucrl%wR_b?}g{x`y_&2t%+~97ugiYxOUxzcHKj#bqlUd@iThFZME*kZ{~)C
z3+79lr0sJ5vCiM(y~}}h+1?`poiPmz&jgzH3a$TXvn}_I@|CX(j(IS|avZ(juxqjR
z;s<M$6qtVfU4MqVm~*X;R8#Xj&sSUI#R4pJ1ZJu;l`+WhUr|`B;90$F;?mSbd<AUB
zgZ42<9u!y?vXH&G<C)8ArSsfQ8<WIJWu8t*6k=g(P%xgy>Y=cH9+Tk|?b*+lRLg4y
z3C-kOaJtA+rGbA#O(Ms!%YnSi$B(SlUU9Da-(>Fu&Pl0kM;%-?%swzV=2!#gf|yA5
z3pF>UI0cD>HP1<}5XhC`$?#<kT+l32D0xVDy5j~Ok^7<w$1gs}Z(umt#4pA$!6BW=
zf$6Z}x(}s>PKtaz5tHPfT`<Z%!oP&ipUdxq4u>oww@)m4XqDgXr7LxGN;@4K=S52e
ucGy&~C@|iukrzmDIdkL8qrga&^x0lDj2sq5=}l~tGA6EDFS~2f0tEn?kquk`

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/float64_LZW_predictor_2.tif b/autotest/gcore/data/gtiff/float64_LZW_predictor_2.tif
new file mode 100644
index 0000000000000000000000000000000000000000..25276fb8ea89e07339443995f3ea0ca529cb48b2
GIT binary patch
literal 1099
zcmebD)MDUZU|<knU|?isU<9&6fS3`9%>-pT0L7W1Y*rwf4ax@T5oBZm>n#FuM3KbB
zplpzt;!rg=nHU&kkkr^h*+5~2U?`gz$mVP2VF1zRfVioJhk*@9KLg_R?aT}cKw1oF
z*T!}x1{okb4CDwn@N<ALVKiI<E5qTLlp{#u%sd}34PrBbeZ$Vczye_doemabV%gX(
z3X<p8*v`fv%D@H;I!1;*Wd<G)9iG7grZtuQ99@je74#KCLwpsg^7B#^3=REiz=Aal
z4GanaYK$3;%#DqT0uDSn3=Vbn4|5n~taO>$4$uFnv8Rm9q1Ig?he5~6QK`u@`QlF=
zD^b3BFQ6SJQRc#Wjt>PrO}2^a&pn!0R1w|4&nIA~=EKEO``L&gIJNkttX#Wc=dskn
zORQRIT<r$xhE^haTRCPQ;t=hK-Q*tBe)&;xl=Qplsr|PX6iUolwOwF^>-zu&k!ZFC
zL%)R*)^Y5-<!cXY+|1P`uE}@W>HUN~XZrriuTR%8XJWl|lFvcHFu?i<@9%)k2i_X(
zVRN&d+mxO7bBA=ZJ(EDF;^aG}-*k6fIx~f>HinyBydYosis!xm<pD2!e%+4Zm-G3$
zB35@NPbY)0SjDGanG0<Dx^FV%JgwKLYg?`M{K3n~dAh6LG-;g<{&J&%k$H`Pp1+jX
z5zBRt+@4tYUGjM|gZGf!cVnMbho0E+)#xzT@e2uZ%wfoyQ0eS3W6wAHfG0t74@@X7
zx^0wovr%II3!#SsHrhN%KMXu4G8pXb*w9eDGQr7LMfJoMdoJsO4o3dNmr82>SaUT!
zl-_pMr(4SMLuVtydZSb7Mn>*iwrVRCY;f4&C~Q=BTY1Bha4V$?OI%JmbKRcTEg|4#
zw?l@TNld^-_;Ai&UykZePkGj5FPh0A93*SI_<T#brqgi-iQ^Z(c)Pl;;=eLw;RO#-
zu67w-BSAK!*MFA!?qA_j&K0=o&7{epXTGSd@CiK=_0O?LHDKvw23A+cvlD{K<2D8S
zoos(@!e2%X&Ahuhb1yDsIO*xXLMAywA&7O=#goNRvc<+?Ir8y~O1<QRZ=R5zE~XZm
zoAtol%lky@?TkP6y7!z|*On`kB>Bpm%I03vJ%L$zmVmiCi?aDj@hLkNKAd<*Cqb@c
zDKF2Z*F5(8cMNnn%XEX11OkGzq|dcGw6mEuYzh`NP)OB$n$-B1r}N;HeOk>gr51`@
j`COX%*ks@L7iU{VogZzVCbjTP*s<knU;R{eX=nfdy0=PS

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/float64_LZW_predictor_3.tif b/autotest/gcore/data/gtiff/float64_LZW_predictor_3.tif
new file mode 100644
index 0000000000000000000000000000000000000000..c3105812eeafd49f542fb0042f5aa7bf0ef6ba04
GIT binary patch
literal 1016
zcmebD)MDUZU|<knU|?isU<9&6fS3`9%>-pT0L7W1Y*rwf4ax@T5oBZm>n#FuM3KbB
zplpzt;!rhhObiS%NNQ}MY-XUEU?etQGY<nu>>Lm`weT>o0qJKzyuO{8K><jM0qxq@
z&cq-CWQTzq0SA5#5GIU<OJHR<Jd<(+Nt~JI1ExW2MzC+#85md~Y@pM@VoWR>+eJb0
z92?u&7(^M^fI-K|(5KA61ERw-SirQVvY(@ik-37tLTHGuLREfVs)C`RUkzBWhM_@#
zLBK*qjF**{k-`6f0t3_k#(fPJ6_{Ue{A1pK`T!dvV<TI?dxL<+14c&nDPE~TJ5#pB
z>QD7l6EJunq-(}v$FP1z_6vc3j1Ko1HoYmca46u=xM1<7&h5bDGp|CemWBlz%{-g<
z{`r?Te80Q*GaO)lz|`>1ICw$GO`d5RBUZ=cg<G-)xW;UD&Ti0R{=mWpbkR0OmcE&7
z&4DYoN-r~)4cXy+gu(oc-AQIfMjihJ!Y_bPz3)hPRI1X{?1@hbf9*|?57iak-@t!k
zh2+nqHiml((!ZDpeN=Y1Bl0_@%TvBF`|F-P^;%&Xb^DX}zaROxTj13N_54Q)%<atE
zZmnFzqi;R)`Hr7Ul{8X3e@@w-wtk~Q@d*~S3Aar)Wcevy_`h*|PyoOA>Q7>Of$8eQ
zS%wo)XN)yoSx@BHpZ|rCd({OYK7j`I9YWO$eQy0=bZP%2v0%@t7)`FlZ&D1!R|Q<+
zIke{F7atb669H^Y@)}8Obu8yul$OrmSN4?f<g7_)YQFe`@0OXz2C=FI?Vr~eDNGEq
z`gdB-XR`j%O;H>|^OtWr_N~Do^H0?Ztp`Fijp+~S3XJq*GA_+wXNfiN@6b8YxbDTO
z90p_06GFAyE^gqcZ~i32waw5|<h$MZ%|93f<||mfYIQmNJC)@^$HX@*EPN)~?)y#V
zY8nI`RQ$s*KU+tL=?J%u$62>S%57_0eYJYMLvwR=Zmd}#BUWv!^F&zNKwFB{TGPj5
z%azbDo{8QpxjdDuitY<UHZmj#{$es~-w`07scRF_c$e3Atyj=N4Izg4?mNG#FM56P
zU;U9Y7dR9nzcer$+WorrzSpWr+)Ef1BuHCy8=p`TW3<rwdo%X>3f0EujVm|+s_rYb

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/generate_test_files.sh b/autotest/gcore/data/gtiff/generate_test_files.sh
new file mode 100755
index 000000000000..99c6e0c63c70
--- /dev/null
+++ b/autotest/gcore/data/gtiff/generate_test_files.sh
@@ -0,0 +1,42 @@
+#!/bin/sh
+
+for codec in NONE LZW LZMA ZSTD DEFLATE JPEG LERC LERC_DEFLATE LERC_ZSTD JXL
+do
+  gdal_translate ../byte.tif byte_${codec}.tif -co COMPRESS=${codec}
+  gdal_translate ../byte.tif byte_${codec}_tiled.tif -co COMPRESS=${codec} -co TILED=YES -co BLOCKXSIZE=16 -co BLOCKYSIZE=16
+done
+
+gdal_translate ../byte.tif byte_LZW_predictor_2.tif -co COMPRESS=LZW -co PREDICTOR=2
+gdal_translate ../byte.tif uint16_LZW_predictor_2.tif -co COMPRESS=LZW -co PREDICTOR=2 -ot UInt16
+gdal_translate ../byte.tif uint32_LZW_predictor_2.tif -co COMPRESS=LZW -co PREDICTOR=2 -ot UInt32
+gdal_translate ../byte.tif uint64_LZW_predictor_2.tif -co COMPRESS=LZW -co PREDICTOR=2 -ot UInt64
+gdal_translate ../byte.tif float32_LZW_predictor_2.tif -co COMPRESS=LZW -co PREDICTOR=2 -ot Float32
+gdal_translate ../byte.tif float64_LZW_predictor_2.tif -co COMPRESS=LZW -co PREDICTOR=2 -ot Float64
+gdal_translate ../byte.tif float32_LZW_predictor_3.tif -co COMPRESS=LZW -co PREDICTOR=3 -ot Float32
+gdal_translate ../byte.tif float64_LZW_predictor_3.tif -co COMPRESS=LZW -co PREDICTOR=3 -ot Float64
+
+for codec in NONE LZW LZMA ZSTD DEFLATE JPEG LERC LERC_DEFLATE LERC_ZSTD JXL WEBP
+do
+  gdal_translate ../rgbsmall.tif rgbsmall_${codec}.tif -co COMPRESS=${codec} -co INTERLEAVE=PIXEL -co WEBP_LOSSLESS=YES
+  gdal_translate ../rgbsmall.tif rgbsmall_${codec}_tiled.tif -co COMPRESS=${codec} -co TILED=YES -co BLOCKXSIZE=16 -co BLOCKYSIZE=32 -co INTERLEAVE=PIXEL -co WEBP_LOSSLESS=YES
+  if test "${codec}" != "WEBP"; then
+    gdal_translate ../rgbsmall.tif rgbsmall_${codec}_separate.tif -co COMPRESS=${codec} -co INTERLEAVE=BAND
+    gdal_translate ../rgbsmall.tif rgbsmall_${codec}_tiled_separate.tif -co COMPRESS=${codec} -co TILED=YES -co BLOCKXSIZE=16 -co BLOCKYSIZE=32 -co INTERLEAVE=BAND
+  fi
+done
+
+gdal_translate ../rgbsmall.tif rgbsmall_JPEG_ycbcr.tif -co COMPRESS=JPEG -co PHOTOMETRIC=YCBCR -co INTERLEAVE=PIXEL
+
+gdal_translate ../rgbsmall.tif rgbsmall_byte_LZW_predictor_2.tif -co COMPRESS=LZW -co PREDICTOR=2
+gdal_translate ../rgbsmall.tif rgbsmall_uint16_LZW_predictor_2.tif -co COMPRESS=LZW -co PREDICTOR=2 -ot UInt16
+gdal_translate ../rgbsmall.tif rgbsmall_uint32_LZW_predictor_2.tif -co COMPRESS=LZW -co PREDICTOR=2 -ot UInt32
+gdal_translate ../rgbsmall.tif rgbsmall_uint64_LZW_predictor_2.tif -co COMPRESS=LZW -co PREDICTOR=2 -ot UInt64
+
+gdal_translate ../stefan_full_rgba.tif stefan_full_rgba_LZW_predictor_2.tif -co COMPRESS=LZW -co PREDICTOR=2
+
+gdal_translate ../stefan_full_greyalpha.tif stefan_full_greyalpha_byte_LZW_predictor_2.tif -co COMPRESS=LZW -co PREDICTOR=2
+gdal_translate ../stefan_full_greyalpha.tif stefan_full_greyalpha_uint16_LZW_predictor_2.tif -co COMPRESS=LZW -co PREDICTOR=2 -ot UInt16
+gdal_translate ../stefan_full_greyalpha.tif stefan_full_greyalpha_uint32_LZW_predictor_2.tif -co COMPRESS=LZW -co PREDICTOR=2 -ot UInt32
+gdal_translate ../stefan_full_greyalpha.tif stefan_full_greyalpha_uint64_LZW_predictor_2.tif -co COMPRESS=LZW -co PREDICTOR=2 -ot UInt64
+
+gdal_translate ../byte.tif byte_5_bands_LZW_predictor_2.tif -co COMPRESS=LZW -co PREDICTOR=2 -b 1 -b 1 -b 1 -b 1 -b 1 -scale_2 0 255 255 0 -scale_4 0 255 255 0
diff --git a/autotest/gcore/data/gtiff/rgbsmall_DEFLATE.tif b/autotest/gcore/data/gtiff/rgbsmall_DEFLATE.tif
new file mode 100644
index 0000000000000000000000000000000000000000..278b30a63fe6109080be94ea96603f99c0a52ca7
GIT binary patch
literal 5722
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
bLo;XkWH7kC%)qC5_F0T<_7MpZidz03gj0fz

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_DEFLATE_separate.tif b/autotest/gcore/data/gtiff/rgbsmall_DEFLATE_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..8426eeefcb8003280be69e8fb6698ce01947cf46
GIT binary patch
literal 5589
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_DEFLATE_tiled.tif b/autotest/gcore/data/gtiff/rgbsmall_DEFLATE_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..d4ef80aa7a33736fa246749056a8cdb0edb6e0bb
GIT binary patch
literal 6198
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
S-~VByMEghu00_sBrT-t-TWF8~

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_DEFLATE_tiled_separate.tif b/autotest/gcore/data/gtiff/rgbsmall_DEFLATE_tiled_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..7ad8879f820cc4559fafcaad38598c398459e5ae
GIT binary patch
literal 6407
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_JPEG.tif b/autotest/gcore/data/gtiff/rgbsmall_JPEG.tif
new file mode 100644
index 0000000000000000000000000000000000000000..33209a3379db0479db3d6c297f233d114ec7e437
GIT binary patch
literal 2706
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
X0N#&?&wu>Ktg2bD9Q!CEh%x?OzY&EN

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_JPEG_separate.tif b/autotest/gcore/data/gtiff/rgbsmall_JPEG_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..f2a6ccd4fab387803958ff5c116051b7c26cb726
GIT binary patch
literal 2916
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
UVkXyB`+8)~tK2Z4HEj+31thwkmjD0&

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_JPEG_tiled.tif b/autotest/gcore/data/gtiff/rgbsmall_JPEG_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..745fc6bb47c50e0c0bcf68203911e48b6a7cb417
GIT binary patch
literal 3739
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_JPEG_tiled_separate.tif b/autotest/gcore/data/gtiff/rgbsmall_JPEG_tiled_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..67e8d8cc8edfffba55ce5c74969c5367f5d5e35c
GIT binary patch
literal 5175
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_JPEG_ycbcr.tif b/autotest/gcore/data/gtiff/rgbsmall_JPEG_ycbcr.tif
new file mode 100644
index 0000000000000000000000000000000000000000..c73e683877f622f19d0bde7bf81420bdebe7008b
GIT binary patch
literal 1634
zcmb7CX;f2J5WX)jc}XOpgiVAXflvu1qKQ!=0YwB{ie(p35DQvL6cOA&Sw#ruND3&l
z#|jqZAcC?lRs|!VLQxPUDvL&>qJk(2SS)IK6XI$6r#-zn^X9v=e0MT4t5?qjBmjUO
z00;^Yh<H$tzhNB2D73wWf@<tUh%pVuAf_RBb#4F-00WI(m1C&ED$bdj7z_^pU1L|h
z=MAwcb`r`)gb1Wi+dzjd4h4`73J&Pw2tf7DCn(y<6m|S%7<2FtMQ!hbxJ--!2K3`$
zQn{F-&UJ>kLX1=YLmw3xJS6oGf%U>9cvN4dMkoHqUHL%S3swLUh7mCWiAW@p$)p(+
zeJVvui!w`B?+blXW3$<&#&kNv(#DEm!C}(rEL&^N0xqA=H?vyeAmG{CEadZ4BnX*I
zrf5-&s8l1KIo+K1zmKxpP~kDT-E{l1&l(p0uP4w@@2Bs#xypL3@$c5ZS}gk<JlzR6
zQ#cs}_6-hdx;t<&5HP5NkSfILiL38YCYe+&R^@1^H2`VhyK_tnq8uTgW1-Lb<$f!@
z83KMRfZdV-8VPO`4@E2hj)tH#MA;1Jkd}ZT)9s%w0>u+BA`T%z??N2_R}P0_1cW^8
zMBpaiX}abF?s81e!t<L*eO^*#z7x@anN@kUbMy^NGKO`d|6qhy$O)j&il!n&5%OOT
zLPi=F4;l3>n7oC{J-s56ls$lgLKYfI1IxhsPZH}}=|?`e4qT}72%6RRI5@vLySu+8
z;J~78Qgn($q2M2<4+=5{JX&Xkbeu8wyz@>dxv?`dNiTJ9XlnkIplh2ZV=bD*O<T%1
zl0>Roe7#*nU5%Gq<RwmhkMpi2Ms8dYK66)uaRDvePS0p|=<u_Eitsg#)YE9rUWLd@
za6CqLL5OPtR>+87JyABt)1c|bc}rH$9>#;$9kHP&v$wu|ADpYO3LMLAqVJz!-SES6
zzuDs+BaY$Rp^NVfzjC_kGJ0f(?90OIuIaVoir3@CzG2I%4us|R`<-wStn&?PcIE;K
z<(a(_c$}{fsWIG;b<rv%BWvZB*g3!1oC}RVG&OOC&Ykz|fR2AhBt492>YqUYynVv>
zF#pi#9eZ3m?Y+)YX-;w4O7OgBGG7`R&}drKFB680t?%46Kht(qWb>WtCTFBwoQkcx
zTYg<Kp=h(OT1yv3l%Nsve&MU7U6*>>INr=sGDw_RG@P9Gb3)J1#Bq~o=QN4zu-T+P
zwSjwuqXhfY?+5plww&%e7|TmwDFNSSX!MirkWqWfs`k7Q?UU|#5{KvPAEVCh^9^hj
z7}V`7VO?<7N)<3BgFX1=6&-0s?H^;-2^*K1{9aRW`RJvjAn(QGrx%RCn82X&mg!R&
zr!qC$uUTi0?A?v}z#(4TgDL7+Hk-WYw)CaLrE;G)C!8&bOq1kV+eJ@rvZFjx<W<%I
z`RPu)qq*1ZUbp2n9*Z~Iwb+uXHK3ivuB~y{>8Qx;744l@wxLyi)2-lWy5-{-y(785
zg!`9@=C-CqP0}O-hYNUDxe5=qWh9!hWNb|FW=%&l;aKX6ffINu0?w9`nH=a?ce{jr
z>Y|Om_UWt!=c$N^Vc$*NkHmSx?|SX9LU)U}xT5OuTv0Kj<XoEVwrBTtHyH)IB)xE1
zCuuvG@v*2hxuWxrlvZ?e@dsD=ddz$7K~f9Tq9N_c=8cgtj6_ntTsmUUPS>i%9=i8+
zx_I61PgvP?HR$r_-W=B5#w4l!c5GF<oZI{`>)u+9pPQSjHus5$b#DKo;Oa`}(bmDN
vCq6NO$F$v=rP*#HU-yZIO=7RyVV$bB3oTXxTn;U;YuC+A7lYgQ1ZDT1`!WjH

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_JXL.tif b/autotest/gcore/data/gtiff/rgbsmall_JXL.tif
new file mode 100644
index 0000000000000000000000000000000000000000..20592eca2426e1fa7e7174912e48bfcdbb24075d
GIT binary patch
literal 4007
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_JXL_separate.tif b/autotest/gcore/data/gtiff/rgbsmall_JXL_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..4c59434abf04f48543ea3c97f6efe2f064151df7
GIT binary patch
literal 5228
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_JXL_tiled.tif b/autotest/gcore/data/gtiff/rgbsmall_JXL_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..380a80dd3ebcd68fa30bb4ec13ab4645d80d292f
GIT binary patch
literal 4629
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_JXL_tiled_separate.tif b/autotest/gcore/data/gtiff/rgbsmall_JXL_tiled_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..b48437146a208244201754a72a772211270b9d1b
GIT binary patch
literal 6281
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
Y^BsF$DXd3LkS1XtK!xZq)=l*P13g&|+W-In

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_LERC.tif b/autotest/gcore/data/gtiff/rgbsmall_LERC.tif
new file mode 100644
index 0000000000000000000000000000000000000000..70333807fd139a177a13660a96e80b8380fb11a7
GIT binary patch
literal 6110
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
H7U+Kf4IRLs

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_LERC_DEFLATE.tif b/autotest/gcore/data/gtiff/rgbsmall_LERC_DEFLATE.tif
new file mode 100644
index 0000000000000000000000000000000000000000..99ab3fe97e52643f3a81683f61feea9c200cb047
GIT binary patch
literal 6005
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_LERC_DEFLATE_separate.tif b/autotest/gcore/data/gtiff/rgbsmall_LERC_DEFLATE_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..5628514f9bd9bfb92fbeea760ba89ef42a5efeb1
GIT binary patch
literal 6422
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_LERC_DEFLATE_tiled.tif b/autotest/gcore/data/gtiff/rgbsmall_LERC_DEFLATE_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..1ff44d77ca5fdae5db4939c106667d467965d41a
GIT binary patch
literal 7554
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_LERC_DEFLATE_tiled_separate.tif b/autotest/gcore/data/gtiff/rgbsmall_LERC_DEFLATE_tiled_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..0de3b132b3e07e05171637b66f42aa13173fa136
GIT binary patch
literal 8359
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_LERC_ZSTD.tif b/autotest/gcore/data/gtiff/rgbsmall_LERC_ZSTD.tif
new file mode 100644
index 0000000000000000000000000000000000000000..13c0bf26a836396febbb3b801031c7ab4717bb93
GIT binary patch
literal 5989
zcmaKrcQl+|wD(6Hz4tmgAw&()8D&HtMDIok61_(oHA9prQAZzwXh9IsJ5i%V^xjK|
z2<DZn-(Bmy|J?Jez0PNU&)#S6eb#y)kOu%f002M%0AOGNFz!j@-Z1_@#=K{&du{99
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
TGIYi@a`phOU?oOiIRgJ5UwyO<

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_LERC_ZSTD_separate.tif b/autotest/gcore/data/gtiff/rgbsmall_LERC_ZSTD_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..c9ce8569d267d624c0977907376b07416dad0122
GIT binary patch
literal 6430
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_LERC_ZSTD_tiled.tif b/autotest/gcore/data/gtiff/rgbsmall_LERC_ZSTD_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..84f4de423887960fd4b815674216b753005aecb6
GIT binary patch
literal 7579
zcmaKQ2UJtd7Vb$%F!TTc5kW%_MF>cj5;~!G>Cy?k_ZDjCgih$a1dy&$6hu*qA}BTl
z6&vcWh{&&4An(Ba@4ENh_12rS=FE5Y*|X=&oV~v(c)SFF004j!03dV#1VnORhWr<X
zf|w4J?SPr?AGtv`0MP$~p`e`WAAG3C_YXd_rTq^^f>`Gtj0UkT1a{Oa0#woi<%eIe
z2WD#!AKJixa@KU_Bisq%v<zl|9+XdkxQ|2!ph3J1;(ih{aM(T;ybX|`M|N-^CbmL>
za8RxY>g>$Gj&!6!e3%eN7dO-l{sxYP{(!E~J*HEE7=pE2VF1v>003k*uqAc?xQqgT
zJRSh>-~&hG=mHgvY^fROYMGdNN4k5tN4je;qS0#jNbewYuzQfVx}c7^sfCrEwKd+{
z?1Gh^ot~97UK?+Mw{Z|edxZqK`vt2D;!U*-^e$N2SlQ~>*jnicYM7W?TbqD&)MO3~
zX)vnE{NF7A+%GKl0{H_q|6Lw+<^OYY;pVI<3ecZgosoZVbxU#T->QfG0Dxlv0Coie
z_67VAM?E_nItcI%2|)~yz_$SX(Q}~?1EQaFScmDT1c2<I$O`_}a2%+DYqzo2I&WZ&
zR+di$Fe5ViZfy{6B#^})f}bk0WsDrNA>}$JoBWL`9(wvxW-&M+wH#01cbTYvg?p|z
zcY5`XHpIE+QZdFs;ZrtMx!C#ZAH&sj>E8<zv@cNcfpT51UoVbX11{jzCo?Ao{&b60
zx{UhMa{d{Q24nA=vv0T<jj!VhFU+$GE^7rxi5571Q7^dEPBCiRQn=gR?i}bBdu#Co
z>T*iX<i{_xz0wr%bXJwG4Mykb*|74X^qs%Wu0D<J4U6j7TC>^`2@jNcLnvCm)2S~i
zB!s7yuyCjCHpsqam(<8V!GgZ&JMTV2>^;UV+dlJSCO1}pJxbv&-3PjWYi(<Z?3{_C
z&PHafmP*9=r1!I0FkO-FwVz3^Fy5b;+Zf!h9~i@{R_TAMaww{oUwHrc!P3Idz2W3l
zmWq0lZ)480k$)toc_Q16F&F6>e&u|L+}KD?Eo!ScFqvg~6sdWMn~#6><1TI1$HMAI
z!U{Wtz*1(r{J4tTV}BWiGC@c*lr@QMrYOg48@+hU(fG>H>Y|MMZDKn=n%me=^v7xQ
z*w)suXcDA@?%cXeD0z8VKfz+jr+I3mn+F<X@!g4;Aywi>W_GBO=y!AZk4soIx)E9}
zyAJV8yX^c{+%2+q3a6|urH-q8U7+Qm7JhOH^O%Q>m)*|Zh*oPg2rT)<mGfm4zAtEh
z`j=7CmLIR^^^?CZI<{QV(ZH3-9eG6{Ohf{Rv@-Dy_mo2)Mo?TX{XQBj4_V<b+7CnO
zkO2bWhd%gH6F>*xo;)1^eG~N6aqvYtSZ2&J^*8p9cXyMk`+=(L+$-HV*)iEMF}^+`
zwmx<~zCJ!NG1(+ic2{mr4keq+NTrN6b~TPObu}_HQmIr%pu4e=3N$tXKsUe$0Mv0&
zVE{reg@YWcT>@IsP<X~|I(<vXn{+4=$&g=WFEIVIj9k<a;ZgWZyKx5jXF~mM312D7
z_LoCh?qC<;MDz^ood<VyE;EFQ=eYB%1^R>{mXO8D%EE%}pPJG+#+u5;3U-J15`kmJ
znIN^(+_c~*EqWg3bQVM-o7#IK90AE7W780PQ-H_;t>J)1GpC79RUv@iG};dWvtat<
zE=@j?L&<)dMiYO1hU`W&KJyEUSlXb`M00<bd2Q1)Cky1Fi3c=upLP517AYMx7E9fe
z@-*5;PAVFbXC2_OBYpZ$V<v&VjM$$hdhB*i+bg)wCz~p+ByP1Wl?6kEb!jerii5|=
zoN;&6*PE`5RyZep%zdlU6^dZ*P9oQa-WcxFAkd43(R*>kxjlJh;Z@45>@8d&aehD)
zUODq_(c+Zd?C#wAR1uv#eMya}pI0I?Yy_#iEN-*!VSIN(Itrh#;h<<vkF{|5`DM9_
z-*v{3WFHK2I+8ND7eyhMdRaIPFJbQ&5Qy(o`~@hrp~X^XvAF6DgI%m!`9sI7Af3}6
zvzhpd<G;^`H{}(vz24E<S|N_jzpB1?-t=R}Yuzu;&FcfYZg*CT5<ZB#sGStvAlbZ3
z)*tc^1&33K)?xiiuWgrhK<m5Cha;4IpxyIJV`+`2IW3U@UR@eZ#Ezkfn(_gYb6vdY
zfJW-jbJ?cF<i@E^LE1FnN(BPlyR^1~Ob*L^S^}mAiT!fk;#GP<cCtrT@yf2rf`=tw
zwBPIMOaR2#hu`;)A{-lM!r`{IyxT!<=R~MR6SmP=60RrzmK%>8Ot`9A74f-1|K7>E
zG7eOCn_)LvY>Q4|;f*L<+)kO5fz@I6hE4Gdwejz>T{bh*`5FC8M$T+!VCB3gJ8gZ%
z-NV>;YF+6`rG`?qMY#^C9G0Kt-HO@xa=)6s9jHa1#MhkM3pc5SBUh?!zA^mu$c>J<
zsy_nVSJN3YXAz`roRy723rbVoa8=*TFo~1MVjY+l9Mvn;jS|7}HgSYEsVRDuO;D>`
z-fLgTNljYybq$>w48_0rfmd<TFVlCPALoX)biEmJG>T#~@Ris0SSwxbdFnu;tz^+u
z{?K?74`{nIu`X>=!DQV2>EUE~UYcg#BYaaj&G?1G7j2yxT7!NeJBE!$^L-s1C09tJ
zb;PXNt3LTkqh06`$Tt(-qxoKlOY%DRhxWb8Q4F%l0!%O6F*I^~iMp3@+tq32_#?jd
zjJ9Bu@u+u6d0|#?<syuNVzVPGbYiT=Cf=66YO6~`2`RXo@@W=mMoU$&3TqGk^+%3N
zJkP_?8}@4OqjrAUvTRS$0yH}Hq`0w%{-?Jjwu|03&YF!4vShQeIQz6utkHAt;_z>N
z*^44h;nMB79fx|Z42Ye{o%+SYz$r4m2Dd<eoV{OYnvKWU)K-f~Nuo35b2eBu4KnVD
z4`$ZM4{9Wy`W^Ob>Ae^4ASz(fPuu8bf9G~F7dk}lc;<cft5*HPKYk_6>Bt_>|F|yv
zuH2+6i-AYqh8SPlQ}!(bm}mY9QXK#;Cg=kByi7{DJk6ZNd2aSGjQLy-ciF<h)Q{M7
z6}Bu5{D(`kIXITkV733{($ym_Jv4ZjKu-PdG!=k5e58W_x1N_DEddUR7w7<Gj)zn`
z!~`%l9<n5u#`_xqkaWpR-JRVv<k9TBSde66V&h_cLF)Cf{a3Q{_KrRz<5*H>c6N4N
zXE%jP>8}}W93N*QgEpAR{ow7;8WW~!3WDAyG77tC!Q8N^Oho8$Df*KqY~YIh#3eH1
z1|2^i59{U)Awhvt<YJ<RkOX@W!bBurKCGsq?n~ldYu5UE*B*}8v|&mYrU%rNZCG^a
zBj`BTPwK&EbOGR2Ccw8es}{PAgJ{E$(*O*~fWT@&m@NQC2HX@=XCnZ}6CuZ#iN#*C
zZ(43IEX(Rac*^@}Xol|QW4|@%<T&s4)*9PwhMh0e%~^jkeDB*=$YiB%-!mSwk5q?i
z!Qti+7o`Uex+z(=1?#R~baAVGLwl?2ZNB-J+RG5>f#;U5=f33FIn!xY+EzaewrMsR
z;$?X~(8QHNZ>O~Imr`8G$e?8WxQ^e20|ouQ*Jb*y=H`3vH-8ixOSEoX>K(nwsvd>u
zbmJ7V_h7ngQ~xBBp`!VTJ5>G;&DbI1qOp@Qi%JAK)hcu6I_Ld`NwJ5zo5HUib$E8u
z<ZJ=Poc@F#T3=%*<7_X10YS&~?W(Ky!br%*0WGH(>6ha_PKO7U7JAdPd9cT}Vl?RX
z1av<RvJyVjwpNXWe3c#gR;Spi)*|%9I8DF=zrXcaRQ@<4z4VD*{e#aibQYD4iTUmO
zZVnCwuM@lqC0b!HvR0Ln%eb1G&^ESY@v=M*2{8tB&(J3V#?PLwBnKA(x*tS+(Fp5}
zU4;8Z%VG~(jqkyBU7kt-{%#x3?v9g31-yu9^j0Nn4r#81tmzU2`)e)oC1?fRfs&JG
zOT6aObzS+QXFF2E^XBaZ+i^ud8g3@n-pTnm?`IS|Y+z<|+M!RObh~a?>B$%7{BO!B
z3Xey_s+&Jg)C_%&qK5H3Tg9yDvIkbby2byZ^L}8t&sUS}$3AogijO}wAxmvWM6UUV
ztlCXl7e}z`kk32+t-boY^_@W&$Cl#X5gn5x6r4+<f;qRx+*D$L(Q`UudgD%J;LeXq
zT?SP;hmxOv0ws#deo~g-kem;KWPHBUm&9Cu)fxT5vJEG|`@5gy?EGutSsqcl{e5)}
zvg_Aoc_o9qT;qW-Z{pTIi89vhx$%STTO@yJp=aD4t5UVgDOsEPijhK7^F)E6v%$;H
z>x-|gF^?i9{P%r+G9ljm1%3Q3Q>Ou%_A=sL8grI%djm)32`{$Ws_Iuf0p9Fyg8rAW
z)MGZg*I!Cv7vR?~W}T`!jwiQ&@LIX_l9Q+_=lsrFEwn<<_bcxRHGFT0Z^N2Cxs(F;
z=>2~4zD};Lh2E_M?yuJSD@Cui^*kW$pOo-Ctz8_pCigkqOuSP*`(L<syHtpSUuM8z
zV}oAzpj`l8B&|aAO-mTDe4viH;6{6Ba@X_zViXI|=6CR7t@L}WFaNQFkEln^{#9@4
zy?)+3O|kR)*qu8gaW{KOu71a+_NmI5#j=rcDt@wHM|D7M)qaRk><z8dOye_VPdqQ-
z{ad!Kg&=#mA%l<UY4Gqg*ue5$?mUk}6|pskAB(!KIU%m~a(%1cZ}!fhfRR5(_(MWv
z%54YKa^54C;=&O1$unF_*|4MrO~vb)Yd`tOM7(jmgX)!o-vLz^d%|eF3O9BCr!-_y
z>*kkCDT~`9eHkaeUN@mWP(?p=EaP0dmuCG`*#OlR%|5u6b&&_v6Y}~lmYZ3e4|(!~
z$k*HI60OmWp#bNN0?V|ix<bLhnXc?iPWPgkxDCD@c^fF-HYWq39Os7L-^m%^P}#mW
zqy9E4E3{x=gUzw_Z5`>2r~32zNhaG)s}_q7wZ_N$MW?yIJ*?g#K^}2@E<}MHc-NF<
z&~H@%+)NE(PBiyfl?q$<v~Q2C*v?!@ui#P)uq<1;94R%H7=gtLnU!p!j6bR~+3$u5
zyCS8lpFe5#%bw+!YZ4MbSnWUpfLOp2P_DUXY&%A+ZqIvGV>P;966EA8c&5NuyK78G
zSx|J5U`^F)YF_ry6)o)^mJKsmqt*y(bElKZ+IO02!ehb~Ti2uR`veSo3ue1tQMy<D
zd9f<`$E9=6)>)pqtZ#j<a69*Y>wdia@%(I7sKq&&aJv`Z=?CiAZR@6OFIr;!o@JHl
z`#)$K)Py06$)5LGfw-lJNXZSx4^Im+wk;vT!~Q#6SD#$hTUh=X)?yG2ql@%c8NeA)
zzQJ~TnaewIt+mGXELio`pM+#A%1qJTk{uqQ!m7n>SldIH|H4ENZF?imX_=ys4tsZ;
z=q3A_sp!QVJ@wj?P`z&>Mvkz$V`is}CUSo<?fD1pI}UfS)%*gcI?7spo{<x!ofScB
zw-{jtlU;Urk?yT~4jyuUE(upKY7QIT_?i%zq(EyrUiQ})hP=smxT172a$;OC+$=4*
z9QT{ylW5N$x~z%GUjjQ)?#r=gQ)Hngov-N!&;0zoq$l=CB^GyIR1Y{n)CXHG*Ik^P
z(G{7Vyf#}%i@a8>IUgZ;s@K7qPkOpWW)QjiE%H6bAJ6Lw9O$Vu$|_y{Ml9P8KE6Io
z{+;3z6!$mJdjZQ;V$G+I<Bf2_#le0#r5H5v)RDjBLxYY3t>XV#6*O|V^P@p;`rlPS
zKDgaF+F{`Wa8s*Q?KoI!C%E}S;s6{D%wRbM5b0BKjj{j~2k!83fExg`0>o?x(1wF)
z;Q&S?BNBi?0gl+{xXcJTtX4*7cu<gOPI%abz_3J@qTB-S058u|xhW<2{yzTn@mZvl
zq-ZDq<O{Lk@qqzp<dooGf~Oq}LdTa^Uf)p(l{Ky|ucuTQ=R~KZRMvGmlMAYo3kwSb
zigOxkQnCtJvnnZt#bwDcrEz726-7m5U5%xs1v!aufCPRXans|i9g+0<y(7h_Rg`JQ
zVZdKXgbkscqY7+FAyAoy!1G1!(mAYb%}i!Vo8$D$Gv$IgauA>c$C3(pCE}#tvD(WE
zZqkri0C>a%<~9HcsRRJo2?&4%pio5!%!ZE5S2qUkod7VW<^T{lCxnX$lBH`S*X1}W
z0@knqb10b8!J*a%%W43wM8Y|?T2#bebzAe>;)J9MpRAkP9q>|PcM#c)<wFrs9TEO>
z2<bJcC$dR`SB}5U(r)v>S{ryd8O6cfNVv&0w$19h9y71*MhX-NGueOGZ8DT#tkT;h
z06=OLVWoNwG2B!{$t{;2TlY0=c^D~SJ9{%PIM0ZiS;T6<&a$5I+g^rnHHCm$4b?3>
z0Y?>M&;UyGtp6Od^lEnud(^3GC}DbNf!!FgUFV!!5Yzx5f+GS;yTJ*NfhDLa9O%Tc
z>G%>tBBJ6F5_6hH#;3vvb&`v%I+*~wLozA1w5*a++tAo{=kER0jYeqs*}ei1Ll1yQ
z=Il8QO&vW`i-6?(DtCRbN=s%G6bhxMrx!qz(@q#V9s}ZiAXA&%_JB?0j%8twKxt@(
zl)@_dGF9DMMEUCX4-O{t<TRvCob1^vkb*mM%**0b{?dfJGxt8-TlHQI4jSb@b8;J!
zRtY(BdmlR6Q-Hkcf872qQ+^s6{0sl<_C804T!#k>{<tg4MWBYCwWF)=`DA~87blBA
zlin)<1jh@OGI-C(R8I#JJu|cLR2xU9(Daz_2v=ugb5k>0ZykLNCqr|*wY9l<h>smW
zPA26QC)Z__WoIXqht4jS7G>r{nE57GwdD|ly#fPEn`4txiW@3QN>hm;VSfIxByV50
zcn`mzn3%Az!nANel<SnRjF7pSDF105g%hboLc)Av{Ls_qB+dy7@$v`@V^n#B#c;NU
zXXM1hkMp1A=fkpdGfSL6bDl<@<kwITgG-Zek|jNRJZ_P`o$755${4ks?mTG8L6q1q
zATe{NtlYY9HD!1#yyO(07<Fxz;#8D>=K)9IJ)4z1;HD%T=CCdy!`)}C^#Pef?TJ6<
zO$xGjrK_L(S?XEGz4vktGi)%i#-`i_O@XM#t<uGSO)g3(m3$a_)cg4eb~l3m2lbI>
zwXoa#y)AhKjHngx4CgAJLDg-TrI*#z6B%Ep0z=_$_O{m}`spQN%_<0eh$IO&`z)`V
zaHn&uD$wvOfNkYB-278+s4NVFRQD>As~AerNRO$O0Ys3#gJv%WxXCB*KUBPuZ&d>^
zC*c-dS+Xo{c4|;Q$LauzwUils^$P7Ffoby2s3MO`ps=4>^xeOrs8^HYOyw&O?WYPv
z?e{QulP4kIH=pBrf7YV2<P7`VBPhUIzpBsO8l@rE3`L$O#==YV!EKLO-^rjy5B8NM
zg@RWSGF9`LIeivB5QaAkefg*ylJ!e9Yj91&+)m?jPYIVwgmz0Tb%_Sdw}!N|C($8S
zB8<wFp7vqnS*<5tn&AulbKp)SoJ@PsUf?ZZOns=Do}j5Jowt9)-_ca&mpfzbh7iME
z`V~`+S<zC*TC3t)Em6h=f(|AD!vR}arCl%mMe?Em0iMr(*2@wzvxYVIJ8g#V->~LA
zApx$d(>Wl5Lliu``g5>I5rc?ClVH1Twr$N%JIG<^Dr;yNnpwGccm;(;CY7jMwd#C+
zUh5WswD$-KiB3q%E-9;OXrT^adaRyKDr#+Z;Mf@TGprbLtonIEPl(W|Ojweh`)ilM
zwSD~p!@{Ft;*!!cN#v5~YfqX@WXd_&BCBianp>$C`})VP&MtIZyHXNp8r6YArn57Y
zdyKda@_rF>R)thvn;mkIX-EAl{#gJ>XukxiZ_rQ&-O0%3>`mYr$2h}T5~uB*BuB2W
zh8}~y|5r@=(gmFYGX5*3d(zK;{eQ)@@4sWZF#tEX9tOsAxNlT)VnSSSa7aY*U}kKv
zo|lVfww;<0R#w<N&_l_>SX0u*(%(CfU}T85bJe!;^l~*av2?a35d1=dL!$zKj)u;@
z?w*0Jx~8VC_2J$&0x3CjFx@}a+EP2Ds>C}n*55KQt+A%DJ}D|Dw=9O#&{z_mn3|i~
z-rmyI)ZAWu=w@e^jVs5OEfjcqkBdEbEPE<R|CUc873vo0$)b7!K`cuh@RG@Gn`Y+{
z6?xG4wJH+R#Yr8BpRs`pk#N>Mdy?w!cy}aM`4)YOgsaK(BjGh@P6GU$9mTZc!Q}}3
zOm%;*b7w?ZB&xrtCP|3h_A@_bd>4QX3=VWq3ez1HdN22PHMNyRWR$j3n_5c)qasuK
zJF4=VTRTcJi*pl;JG-cLIhoqgNtyKxHKpgtRm8-Ys1*EROk*iQ-#sXRb+rs>eBZ02
z2(KUU*}rfubzpowR`z^edg^{Y-_tva>2O(A6T`~i;+9>{HtCF5@DK?S?s8+_-dXNc
z4yWzo69PHZ#mw~uhM3zAT4u)Ps#S2lt%4Wr%~}R;3d^0>6N~zABbjtdO2Gu4K!Sig
zWZGLX!Ije8;$_EltA0`uh0$z_?^}GRlV!|3qe9$-S&w<$6Xbj=Eb3tXSNU8^bkT#b
zXui+EMICm2wjNzZuu`V-oqjX^9Gx}6CXG?n=@oWAFU-`Na6e0lEB0pEP7fu-?0etN
zF<7^+eNy`Uw;7z3g!BGhbM+>M(PQ95PZ}TNo8T3^F&}eKh+QcL0dwE2+zUlO9eWkH
z#8H6Tr#oR7B<#7=J1mw50c&Wet%%Z9Q);cHkZsN>D)hIMX8R~9$X)8Jx7U=HmTKs1
zAZn?IW6CIH9yl2(v8L)kO+`5wsfKD3#j|H+rQxhuxaWSi&gcfMa*wTZSJzea%86BX
zkf7$rvYvgQI{ZrF!Xz|c;`wuZnjCUZ)@HtmD>)2mB+l5v+BGaPE<TBvnwgd7yLJ#D
zq*a~^um#5_q@-1V^Ko+<wWqiH`GTK<KxB3Yjy?63r-%Dh4>`xrkG}0^e7N!$eO5Qa
za>)vSgR?zrzJab>lZ|`>HeUT$k70z~RR=o`04^dag*_{;ps1v&lV4mxS&a7<eo<r3
z$<kPs3(uP)DAbrChTJ>sZ<oaBfy<-AiJb*#;$e|OEZGgYYN=1HkJ^f!AE<!1a;mR+
z49)Np*^rIQM^p6*ki-B)TdJubqtXFDhzM|w`Ec1Z?vLKICedf*+=GY-TXpgM;WZAO
zwQyQmT?uAzsx#yJuF8DMN3q)4r>!Ag8W07}0JK1+@Ek2DzE>kz(2?`By*IVAwK@v1
z`Yc2zW$FR#KHEVvVklylF1tnL6&0a5E%P<tj|A-}-M;GP!aN?2Z$G7<1uw(3#k~yK
zn@f3J`7`LCRhDyp@)wJ=YD>Oct8$WS!PU=OGCMVY&P@KrM%iaw5i*E+J{)VW%;-LS
z-rIfLSbW`OYtcsX;RIoA{dlZ*LHAkl*C}%NDkM{?LB_{<8t{5^?}FR%?8nrfk@hei
zv;|bKd2im59($DoQ2r_OmC#SN^1bo>=9&JvYA<JAoY}R&=XaqkpAyU-IaWH^^<8#;
Jt$M_V{|D=OJTCwM

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_LERC_ZSTD_tiled_separate.tif b/autotest/gcore/data/gtiff/rgbsmall_LERC_ZSTD_tiled_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..91ed277e5e9b24575e09f8191591fc06909502a9
GIT binary patch
literal 8618
zcmaKR2V7H0*Zw3V7<%X}KnN}LE=9_vhu%Uj(tC$cLVzTM1VZmk=^ar)S+T9G3WB|W
zB8#qTL0!w**Db!^cf;%V+kN-l|3CLPnUga&b7!7&=FBtay1VND3;;k900bXEz>*1E
z5Py-8u*?VR-ob_MtKO{|0RFEs64pz9m3jB!{-SsMDq~^2(^nY}%gzWCkb`R?{6H62
z&yzpHB@mW*eN@AG(MsVR83R9n$r1+qupSS~hd6uy56gbAe3&B)c+YQwzh*heotX^4
zGJOOI@?d=j+|Rou)XqH(u*~~lcCKe&9ifW64h#{+@U;*844xy@;op`BDuRXR1#93N
zgaUFA5D-O(6htSOfO~C%hn9#2fV~TVU>LM20RX-T0zeT4KwJdwS`>iiVgQIp0B{d3
z(oz64O2gR70&oy6On91>3IGJ)0FY1uz)Tr{X%)C#6-IpLLcyKz=40dL?BL~{SP+{K
zTM%m}h{xNw7bIrlvtlz7Z3#}k-hKftfr0M6K6?XPf?Wav-5uS%+{s}Cd_s0+Y-*M*
z!QI=z&1G*OIUvZ192DR}u=DZ_4D^EkV`Iqc$WGA4@IRjbWPb4boS~Fq|9>?+i2v^=
zN=CA`G2L}>bII)1>DRj#|L<nrJOF?Jf~SIj=K>pgXJ$OpAiy>jftlsNt$=^$cY~S$
z<}io%AEBKZwtQwmhtfzM1m6OUkwYCq+ye2IW;8&YH~bQ#2tM+IAt8NJBXJh6FzfNv
zTmB~QRLMOVW~!~h7{VaA_nMT5L?QFx=X(a|u*U;E-@Vspm?i7ac<<k}*&#87eJTCe
zDYd!K)bsa=4bDLIo9i2f#&_RHmA`p!a%z);so<=*sI8nEGR-nD3*`HfXrg$4)|IjC
zO1riqmEZh`1+KsIJuKaz{`B#)GhTo2&HpT9zV~bc(PNF7W)tI+diB~kdmX(h`b7B;
zKCv%9XTJ%w8UV{G{=zc2PH8O2Jbxw}TUirZeeCS%nCgQ}v8U~0nMO}f@53b)jVjT1
znJwl%mE4&p3K1m=+7!GJ^WshLJfApZgM5OAYu-BAabws?U;qIM`M@5eLmLb_+=N0P
z5Q@>TR@gbaEFG>%ocx4Dc!6c6ro^QK{;K5s)Qo6gkdvL29Fu_n90*`B^mB;N87W6Z
zTid$%?Vb;b{Ye>xCHoyuqDK^!RFdcEpxq<OuAA;8ed%@Hr0l!kpVqC9ugwLQENLEc
z`|0LyEY~CCgMQ&=9`hatj|i}{<`KI&P`~i5N0Y^NIMS%`MV$JQ1PZTRVxu28^#MCu
zXyLy6L;|tbNKvog{O#R@W}?MK!v4Oi`WG%L#iIfO!^jcw2~lLv;PCkH$f%eMH;>S$
zwDN?cu&~7R!V_tp5rIDBk&UpJ_`JPkeHYU*f+MVgZeLF!+1TotWELQ7IFNp4D%;cA
z80uM09z94opC&MOIB~}3mH<I6DnmC;#2o1yynB3oEnwDpUR=<eLDJFZ)|)k-BBKpB
zkc!O8LxA(>YhOKQQsra6^}Ln36t3XI9V`8geCURA)x&+EqY{%Ngzk*}*OH|q2Azkl
zO^p)d8%6L<$nXz#H`qVw<bc@d`^kzvwpSWFF^JMzLY84P<c?9*5vQ?$h5ys2#gkVJ
z@UWTwZd7&Hs2FH5g>M-)HXjF~dmOR*S3~2_kuO6075%xzcYfQ79=?C-w#R7RciV42
zYkymKDC<?b7b>p%We&MqIeqxSM4rNx<o#$<Hl)xWc<)%%58a(FKCO?Fm{A^c59FAt
z1G#CT%=k}~AvxFNjhHlQn$|?>gJ8yXM+?G%1L0RM<b2K`2zzqH=N5oW!vyQDvz$0$
z37HG2H+d`#b*EU%);)2YouDdSO#09*|Gvj-bac?U92FiILLz$ygoef?djtmih6V)&
z#RUfkM1*+-`1l2d2Zu+7hsH$shc6cd#rpW#hO-N8eZr!>gA2$(zOG?`!64El*wrJ*
z#xpc1kCu_@7s*ZwNMOc>1y_HU;Sn3`=YRHiMND{*m-j+Lf{%}vmtS2$kh=pZFf_`~
zj~wZz=ZDr~LkG9!vW1c}+zOSF+0!~%_g$~V^$tA~Y8$wa82ch;CfqHBJ9fxw8T&_H
zOlsdd*K&jw2bz~jPr8LLnh#4czf|vWQpxC6t+uB8Eq=*qC9$c!FIt4={dD~G0)-n$
z2jsaQsP}A0`>_^}5V>d_4rH>PUQo-jTy0CYj6U9Cpxr=vMCJ;w`5bcqp&deR&1+|(
zEkbjH9v+sPjxbh#>u2<B!pHGE2OTtkj24O$v0IC)+y7qmQox)am|W2|@+;a6nsPX^
z#=*Ya+eWd>Bk7e6qd?=;Ov0p72(sbY3u#i>DMR+>`(Ai9(b?q7=ILK>+Ya_6Zf9lB
zBHxBak&Ct0o_{xZl%mh=EX;b>l1)?Pn@auh0MRUkcB)H|l$GCJ>qGqs=PPdPwX)BT
zKhK1KIa*75jLkm&lgydpLiqQwgEzVzj^lHT4Ju#%Ze160OK8u+;^2jE%N~Epu@RGN
zCLd^b76j6ooT+8g>3zo1&kyT-@>dN$h$x2ma7A{A9fuD9`T}4C`=`U(@t^4UCx;I}
zz)>s(S{#E=4BkGAg#ZM>1+EtX9fbrE#f2qR`FutWtem{eOz)b!+`SpOw5UdIePVh-
zyfU|<r7kTgji1WqRFoA)q?PY2&ZB0eGn*>1vQpxM5nvn=VIUrAM7WM`&M3f}G}ZxL
zb}?{a!eta-;r$&LpF#j5v;_wWAMxv;o{rf{eJzP#s4MPY{V<zgBOa#lp%^Dcmm1Gc
zTg4b`>1`O75f)^hupLL^i~`*fB0NfvZh(#k6Ofowa!PhSrKFTrGdO>8F*jwu?$r^e
zDuCn{01ws~BCBU&-<W#!4|n*98!aGYbLM_U?Z7nwC_;cG{U=;DXOe!y!vp+#e3;<D
zl?*MwO{sz5(a9m@X=zarei>df3+XB0d;JaF;|mz^VO}miK6wmsctlQRQC@y@q^Ga9
zPf((ht6c=i*F7-M*Ec&Um>2YPTMm4diz!H+upPbCCg>P(`POg^riCnkC9Wz5#7r*_
zvf?g1kkmePJbFw|a<|!b99qgfe#kNoq050*zOQXhxjb>AD}!VTj7F45Pyc8qS*oKD
zJu{X~T>`CmY~14TEGE-6%zj29#QUcdrS;tlbpgFcpEe}prX+OxuJ>-C?Md7T&pmfj
zzG+eW(Bkh*cN1Pd;^24&pS_Up(Qa|~5YbFD@YDkz_xiLN1P@<JI|q_aKvY~pW^O@Q
zi`D6XiTfcA%YcVH)-gFXBR7vyR8m%1#c66O{B~o=%dlM%27eb|Y-*np&K47%#E9&x
zOt-rGH7<|wa6kGN+#h)uX#W%LV?5lUBxnu>J};S4PAe_R%F50!pQ|d)a!H7auMW2H
zFfvy6&4{z`^R(9``==#lq<E0rgQFb-;uE4hy!;~rQ&Lj1vvMfuXf+NLc;K_H?Y6=@
z-A&xpq(=3gri=4=y?DtK^mcH!_xP=2`L0#AY0`W2HAQrKezq>t(Ylc8yUX(mK)_Mw
z*ubIBrZNnPh&QsQRBNWLR^7WKP;}we@Y0FZ9xEt$gm5s_XL#<sx=DzO7UlW5a?Y}z
zxfi;WgBImLiJy8;pC<~&&B`BO;shUOt+{*Rgfp{)TZtG{?1#?JIT&R4jJdS76o`3w
zIhTk<-PhYTGLpmaz{f(Keu2@s1trunI-`nRo4oa}bTx-|E{y&-BwFX@Y%)kT>o=m>
z?m9rqcR3vvECEB$517;gi|fY;!i#(g4;J1F@cbQrZ9fV)x~mxE)TkkR@>4ITi$4s~
zYBWQMHi7FLcX^dv&YLpFEXMh3txkF$4ayqO+2hzYBDUr{GZxyr{K&;}-;bNRXKWtq
ztDLH1c$@S@-fkuOH`3l;7Zc6pX8+;%P(k?wtAQQ!RvR0&(HmNfl(v=IQuQ@dD!m<M
z*0pC&n88FqyTHQZNOFFI;B1}<JhqKf{~lY62+-dJ2qGrCp?oH=nNq5}u_&thQ`7UN
zrP1!N%@;uz+a{AvSMO7kn)%h}2i$>23fBaT$j+ZVL)^zcocYCeR7xm)^p)z^8)uCO
zw3f4a!<L2~;alG|7Y}PJYdyq|EZ<o!<UV1&p<*n~Fe|&8W@`~{Pd>Kj@EcfB3Hnjh
zvP4OZoxba|U$Rbh=|G5}{7V((sB?AHU5{5Eo*nrn{@Y*q&u70MUrZX<e)yyMd#3ml
ze~$Lv+E+&wM30@VORM<w`=S5&!$Lte<KrcLhGXR;tRRT1KFVD)e)yvkt4-G+DD#QJ
zU-_me;)^JFtoUc>={IDF{L>N;<?&5?I&}9d;Y1?&P)bPvfy8<ivrAx8lRMdkG{EOY
zqccm{NI`BvLk+hSX<o{#<5twd$4Vspfe9=Eg^>_LA(1GNl*|Mb<z41++0_L(aiK*y
ztP*NQ5v72ELI$v^TB~SfeAt{KPEJ8SS~j<|k;yL8ETK{=D~eeeELt{|mPJb`&MwK#
zE1(tA6AKdKbBePna<ds(CB=wf4utdMe{{Uqu7^Ehd=ZPg;LrC46J=!5=E1t&l(gub
ztTA-m=VX7~xriZkqGa`U&1>e6Z+#*69to9SNGmF5u`BXYi^|w#<)y{!#Prf~b~}w;
zRLEp=mN^-;oW%I4yTuGveJ;E2VpV-1#UuL8Ix{sg41!9kj&Id!z86uusIv0ZtUP%+
zb22u@yx(X2IRZE&7$zJXwe|`>@sn)f^m?#WNd5K=nzN~2GyiXoQ_yZ4Xej*RBY+Ra
zhwHhN&SstIKR|geP`OV$a{(n$W*I^%N`F;;Sbl~*{Jd@AcKRpouZ7cXA|a(wr-eZ>
zT>zPPU}Z*WY$Ebk;_c2PH~rcFSaUJjh;=Mz`wIs>YVY6hPlncp4gF>@9YWlf4`JpP
z(Ni_EstO8A=|vT+!u%{+X;DF2QBg6K$!4-DbE+$<DjH}dHEAi8MRk?=oei~28nZCF
zxOk9Jhz?;xA<Cxf9qo^%TGKu~e-_G)pf2|l*{av8rb%o~E$%kaV_G0HtG4jKT}nb%
zbNa>*B8me|)~DVusxgxl&xqT+EZQ&e;v*uA(8JnQ&`s8q^|>H<mS)%I%ZZ;I$y4>7
zI3M<8L*<%_hA~J$G0Q4)XcQ{FjN6!3TwYXBTukMbl@(PKW)|fal$22^C1s`b(){xK
zjfKpt?7ihZ4dFSZ%v>rrmy(-SUPJ{IaT&ou@&3t_9CjU*mO<|+Ponl#(8^kGFq2uO
zl;YKuo=PSyC-=LdDhee(C$GP`C?_SOkVd5xl~xw{=A(VtklvRQxkB-?U2K&Qrcp+@
zirZ@P)||F*+mClr6ZOho_k_H@G<A6Dr*4tnL7iJ=p?L@r2il`puO)>vSlr8%(d!^N
z4;ml+!&YaYZI_guoxDEY>-^ETDMo8oMy_mToEoSvv@uDJd}dbC7Cwyj;y`BIjWS2;
zEH8Dx*(^WZX7W1!1z%8|#HJZF4}=fhq{uy9N?O?)WU*%z4<(u{Sq16cdEJTWbs_Qt
zBEvz>==DYX0;Bbc)(#KZp`pynM57p(hAv_=tZ6cJ#;p_ls_3Y^J_SaJx2;FIf?}_7
z_V0WXG2$wxrYTWFwKpBcRPNaCjoRKbZoh^9I2a!6LGrl2D-|{OVD7pY`F|R$T|j+W
zQsR46qZ}*gjqRIC+nR=-k<SR4*h7_O53!jk!jX*&=atIe)g;?&Tj*)EOSOpyl2+e8
zbKdyWvgs(Rn4`xOdRg+~t~uIkd>e!#U4LO<gh7p7qe+v+^dBvAAIW^hIu4<UzY`^O
zUjdr|M8lr`o%zrKMF6P(g@&FNn0@(AK2P7--_xPZF^Hc54H!cJ3Bg$ih{qI10KFQ8
z;KS9n_l<WVjXitX`?|Y4YYHnWI`>aRHr4l(H#F3%HrEXFR<IjH*`3`D&28mHttD*@
z9gU4`lLM`-^))mkayJ4+<`YYHE<z`k3NvcZk_c&Z3<o;1CHA!EO5D=JD+Q|c>O!H<
zKMay|1iM^5qyWI^N?Ge!#T*@M?B=!`oVb@v8eT8Z30gT{n^ntWwkYN~NdRw|Jo+OZ
zR?gwJwsm&z>mL}seC6imj|0ed(?j(dq&PS>i-X0VLj*e%hvYLSb4{O851G@mMy;?0
zbLUXi1Ew!07Ig3Y6}JgcB?Q*~!i&gd?Jw})|G`J`Y0wS0t*M+-+g!e%-Bw*))}FI+
zqqVWBCf_Hyylb?Eo|TZ1(K=LIUeVm&(bCGGXXmD-6>}1kW2kYdnMFmpxed%bv^NJL
z@(5`PD>i9s<W`e}%|@E!`EG3U+T`J;S9;%%UwdY<&LR_wJ-ub>2Q#GZj2JWnGFM8C
z(S-2jKv$zh*na0H?7CkSJAvK%x|dvSI~<Rwo^5(}d^el`P*1ffyz+uFb-KL7+pGgK
zrd+QX`k8p8{0usR0~wAre$H4{C-&voxDdRp`4ZFeKNe02KX`W{mV_Y9@UMB>t!TD}
z?+a*N9;SHK6T-aGkEXw7x9;$w(74R(!ct~+OIug}@YE6Ffq=Vbb~`-XVWnaPJ-z#f
zMy3uPI(+i<%BAsd7g{pBDLhij59phde`iK9b6{Nv6v+I!9TOHq{r?I1IiAN3q(k>$
z<j4Cb4ox4Jo!mb-IC<~r%xDUyylSp8tvJx%F}tfJkyf1MPh$@B4)m2#inwh>oc@6p
zDviNqjExPC4i1g=pl0W0$GaOU!!FGnJ3Ki!+Lq619h({)Y0aP%R2&}fsv8;^Z>ehL
z(wZkGr}o!WITn^x_4W6*hBS52X+@L@cLZ!Y@0pHM(iPLg3Bf|keP?z{5$#8*hpw(W
zu{~v$tmscsfhQ8K5hS0eYliv0XkQ&JY`m3Qh<laQi0bd(*FkZ%u^8Fc-9+BA+x+lw
zYju)^xyd&ZeWCVd273Jy{d5N_ZDLz@TO4Glr#0A<VZYnNP_MtoYqzPXvBA#4Ad6aB
z!R&yYe`s{-z|8dhOR46n1=asP7-;C~8JU`y@3ydas%!4(zDiA0|DiYZ-!@=uzWuum
z@YmZ>fVrZi%VVe8?^!p6FpeD!O?I}xD2x?LA2>Oe)~lNoG175&@4!8c4bN*q-Ly65
zG8@MA6U&bX4X5)iK11D^suhYMFovM>4t-8FCmwfH*uANe?%Yt2lfoKd;bfdq=St~D
z^ru4W+C6>IREq8c{3EM#CrtPlegZHr^)~;u@uG%be&c_W(;$8@=b>#DlQ|52T4qr{
zAyE^~iKk|tY>_aW%^0K<yLn0OaAy{Nu+j6W$>}HSXCnF(BmzwcUn*2O<MU@fXI82^
zMJm&UiO)PY_rG-VLWO)%)>6CS@3>_6`Fh=2cxsBWJvy!vDgW$1(_4FSg3>Rl*EZ*}
z!O84i%bvcMx;Q&}wA0IzI*8gOONpmPWj!zcfv#N?G4i;)_t#$yE1r+H4@&+^GF-!k
zxFrh6EQ=rc@u6askT9P8-N8i1=?DM%r91UMGoC+#L=ixi|I_7vd-GP}pIrXu9hXmn
z=9zF{78FDX!sdk&nc?sXz$?gv!SNb3+DroAS(0E`0HC*hAWYf-PlF|ssz?N2L*SS<
zAK!xkjq<S{*UJs$f*)VlkA~HYm&T6@uz_FFWI-5+DW4@3(hnu6r_>unc?`%=x<kq~
z#~1_03$9m|kV|59WT?EfTyO32*}-CK+2s-O6T%96MB%q5VMJvSZPp4aQk#$UxMtB=
zL)zU@jVsf2358a@S<s9TY&TxDLE&(CMS?a_6(^2UC92@n2!>)3DrzQf>RPG<0}H2W
zU2!#KB_i#RqNXln8bTW(nyBhYn$924!U~9?#XNlwC=R52WBce&;%Y|Z$J+_qR5Q(I
zHzphg?He$0c$YYp?{%b*5P53v&DMZ<*J&>;vt~boAy*;t?Bz%_nhlACx(FN5#8><i
zlQR!ra^KoTtv}zcdnZwiT^tr))-{&cAGE*4JnD9W)m=0<rtlgDAd0@zIB{h2zcM_k
zh$=Yk{1-Zz?fxtEpRA_JJ2wo(LG7@qK<Y-^U29g9ud~jene}FMzG}^GMa8G@5iqm6
zx%yC|8!{G4eiB+|aHvJ&X?VTmh^KR<0M~$LrXPNY|DiKCOs*(-dFkQpOhxOd@C%vB
zO{p5cWDcMUqb?Z7U5M1sj($`a)q~C)aw!K|@>(Lo8ftQ~Duxn7B@2v-nx?k0I!;yr
zBc~uEtB8|PR8S-+sA(!G<CGOu%t?58ybcixs#eA0b`v#JeNd{3Dp;Jf0$y3$P(of=
zmY}StsDsBVXb@x+WE51?2<jSYD!Q6Vnk|ruw!DIXW&nhdS0~Ei?N#s!SXCuFP!m;^
zRwN25sH!=5+ghs-1FckzJ+uk<kQOUxB2G@Ro#U=eP?3?Zi!hLrlat3q+2f@}qzD>1
zayVs898l#=dqke87V3&;dHb(r{=o5G`*8HO9P_>aUB<=bPIZFDhNcRJt5vlBLJ2$g
z8;Z_SEYHz3FVqYRdX34Ys%$bQtPN9%W-CvKeG7a_N(LHyh2Ogv7zqX4Np{(%shKmu
zjY_5RRuR$X*+Y*Q;+d<QF^$n`tzq|XF8Z;mt_n!2f`B@g18_EmtlOm5I@l#DEB-R~
zy0hMB=hdUe`pRhFRuy`j{{ccIXX|S+O90HH!Mi$5eLq?Em2|})E+Q{;J*Gp}Ro)7q
zt|m;HR}9WeIiyJ6W1l#g-4|!#f4|LDP5a~e{Iz{gY(uP`$?pZ&Fbe?@ne2Ci-3x->
zbc(RPw|Sz~`Prd<xq)<fqBc|&V|CdjWZ_e7DGsI9{zs0AnA^aK)syzLg1SK3WBoQ^
zF>X5_H9IC>AQR_~*)Q<B`Nvx#eeE8?BfAnraf1z90T96H625DtLv7c&_+Osw0hTa;
zCH7}L8g4pu?4LZ_gBOqDp{`K~<p2jH_@oUWIBB^PlmPu{+>>BB=h3t9ZjTX7p{20d
zG(8P5jAM;8c&dkysv?2=S7lmPjf{Jjs#-?F&pyy^C)AkmSe+1p?MybA3_q>`2R1*r
z<iMp8P6fKcbq{=k_K*?Q2$&7_?-P9gnWf&-og%fF<J=~XmTD&Aft03c+N!X@=5&!b
zMfqDPb$(=h@Codg(;kyd1Q>&m)?YJ~a)zdR?ChOfy#3P4>$+lH;Y{Ul6$R!cLU5)M
zabPg@TqM(+?)nWu(x`E6`es}XpTUEKuPKr-kO`BNztBVF=(I#UJi5Q9D|gan4`QK4
zxJ^@9S=~_0*G5xGMb2EF(Ws`5(^5jJ?9thyuBITTu1>U;Q`drmNctvP+OkS2N;o5N
z8DSlHyrc?VQOV9+iwEn}%{q*DOiJ2w+xhSJp)M%R4A<5RO0B`K!%pMex-Ovn69N`D
z43i`3N$S($qmSlYD_gXNtT3*;7hZd$pPBkiwCIbk-bMn2zD-w|5sID35E3ijY=mxs
zZvj4s6f<w%`eLc8mbF$|WnCvMnRMxS%H)GIjamv&m3x&MctdAth17d<f_(Jmxj+SZ
z9pL=DQUXCZ((R7!d6lKnD4?M;NEi#M4(k1NC-p2Q=*kKZs0lbMmm{yiXLZV-b3e_o
z4c@lKA#A0%KzrPL^qj)aT9MX>&Tm(aL>Z1r!3Nj`6GN??Y~>6_^l)X8)$6a>%6{-s
z5F|+b>6lu4RdN3Wd;iX9CKAf!K&Cf5J5S#5Gnbo@)w&<vc2}4G2~LNBj46m0v6jcs
z+ZeM6hTPG!;?kNLw<g|p6%Z#Sr{<|kWFFc^-I<@_x<O!%A?M_mgqB8k*Zfy$4XcdV
zllO{^LuxA-U+QpoFYm5I8;g38I)B&ppZxwQpNEM1cyMY^+@uGpRjB>lVIQR$r!B&u
z-Eq;gYvQR1#Kp&Xss1_(p+1fg>pEJYGf!3p0>`#qTKxXe2QA8m?x!y6J7;dnoVX{`
zv%h1;M5||<gY@0S{{Hz?*l%Uh#L|8uRf(H47{*oHSM|80g|}eD8O!l;v8Urq!e8Bf
z|AqB@;SS!^ndN^yU<YWCfi^C>b~VMk*9UVXc0BY#ONk4NG6pcH#5Yc#lr0;=GhA}$
zN@kb7zJkRsQBWXY1*e;n+yc&LD_b*EmD{XJ_|OF5$jr_#kKy@zCvzpri;)lRo~vY`
z0N1u2vEW4g=myStNz#}6i$^@6A1t-1vTlYhM&9;xQ+lxFu4Q@7eEk_DM8vAHgbkW6
zJ`zc}_C8BN;_3qRyy^v<wdb~=-uGUSS^|JS|MSH1oTqfKJT5U~lmZXyWXV&>{{==8
Bad`j$

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_LERC_separate.tif b/autotest/gcore/data/gtiff/rgbsmall_LERC_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..ef09a526195c0a0f01c006e70ba09d887965623d
GIT binary patch
literal 6679
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_LERC_tiled.tif b/autotest/gcore/data/gtiff/rgbsmall_LERC_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..bbdf43f3a2cd5ccad516a33607b80a1f3b4ace67
GIT binary patch
literal 8426
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
Q;{hLp|DHg}-^cX-0q{L|@c;k-

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_LERC_tiled_separate.tif b/autotest/gcore/data/gtiff/rgbsmall_LERC_tiled_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..388a003ec3123c685c45ad9047807c8715c7d28f
GIT binary patch
literal 9706
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
Ly}vgDyuJS)M5i@p

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_LZMA.tif b/autotest/gcore/data/gtiff/rgbsmall_LZMA.tif
new file mode 100644
index 0000000000000000000000000000000000000000..51986a85893f65f82dc10f93e3c2d59d54802c66
GIT binary patch
literal 5138
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
V4*+__?E)nL>ciie8USc%|3AfVUZDU0

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_LZMA_separate.tif b/autotest/gcore/data/gtiff/rgbsmall_LZMA_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..92eb3b6ca68dd4fd23e60e8c957d5ab953f3b0f5
GIT binary patch
literal 5712
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_LZMA_tiled.tif b/autotest/gcore/data/gtiff/rgbsmall_LZMA_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..6f683d04606ad731556205bec32ad69082f93c00
GIT binary patch
literal 6110
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_LZMA_tiled_separate.tif b/autotest/gcore/data/gtiff/rgbsmall_LZMA_tiled_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..774616590706e791301529d2083c0403685383b4
GIT binary patch
literal 7850
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
NhWeDI{o_A<_%HH$G++P#

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_LZW.tif b/autotest/gcore/data/gtiff/rgbsmall_LZW.tif
new file mode 100644
index 0000000000000000000000000000000000000000..1eaaa7ca1e6b80465624a30744ed370d5b32a486
GIT binary patch
literal 7107
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_LZW_separate.tif b/autotest/gcore/data/gtiff/rgbsmall_LZW_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..fea740d0f2d7e5ae3815a94a58b034a5dbbcced2
GIT binary patch
literal 6846
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
K(ij7Up#K7-;KsZF

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_LZW_tiled.tif b/autotest/gcore/data/gtiff/rgbsmall_LZW_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..29f7795aad8f16adfc8f713b70951e73b0177625
GIT binary patch
literal 7303
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
F{{RYLa2Nmp

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_LZW_tiled_separate.tif b/autotest/gcore/data/gtiff/rgbsmall_LZW_tiled_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..08da747a06ff612c5495c79ba561dbfc7f9d9b74
GIT binary patch
literal 7449
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_NONE.tif b/autotest/gcore/data/gtiff/rgbsmall_NONE.tif
new file mode 100644
index 0000000000000000000000000000000000000000..c44ca9eb76553c901ef46d0ff57b7ba99fbc03ad
GIT binary patch
literal 7878
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_NONE_separate.tif b/autotest/gcore/data/gtiff/rgbsmall_NONE_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..89b6c969ccded63578c31dd4b276dcc26e0bdc74
GIT binary patch
literal 7896
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_NONE_tiled.tif b/autotest/gcore/data/gtiff/rgbsmall_NONE_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..c4fe461c6008ac3d7639966b20d010e9697b77f1
GIT binary patch
literal 12726
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
SLH_UN^h3`N8u;JWz<&eM8#XZj

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_NONE_tiled_separate.tif b/autotest/gcore/data/gtiff/rgbsmall_NONE_tiled_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..93b8786e3298466cd03b243a5121afe28fc03a2a
GIT binary patch
literal 12822
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_WEBP.tif b/autotest/gcore/data/gtiff/rgbsmall_WEBP.tif
new file mode 100644
index 0000000000000000000000000000000000000000..d2eabd6e508d2a5267914873ca5ac867657a7f72
GIT binary patch
literal 4178
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_WEBP_tiled.tif b/autotest/gcore/data/gtiff/rgbsmall_WEBP_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..32d5d4eccceac25268a9aded541138340c61e30e
GIT binary patch
literal 5112
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
TZ-`?oX~Xq~O@7__6%P6z%*W8d

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_ZSTD.tif b/autotest/gcore/data/gtiff/rgbsmall_ZSTD.tif
new file mode 100644
index 0000000000000000000000000000000000000000..ca10cae5e758affef9ec361586481a1813755598
GIT binary patch
literal 5873
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
XF2tVN*$1i?8JM{1m8_q6<ZAo}YFFSx

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_ZSTD_separate.tif b/autotest/gcore/data/gtiff/rgbsmall_ZSTD_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..b43d103005fe3a29576c4add5e849f7d2be4e2ce
GIT binary patch
literal 5609
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
NVd_L9je&L2{{!lETd4p5

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_ZSTD_tiled.tif b/autotest/gcore/data/gtiff/rgbsmall_ZSTD_tiled.tif
new file mode 100644
index 0000000000000000000000000000000000000000..b0ad9e074836d5c97bc3d83a5fd030634ad2be27
GIT binary patch
literal 6305
zcmZ`-cUTiy*PnnCkq)5;LK0FSA)Vd=O78&z2%!@QB?-NRgciE=-aCjOMeGd}ds{@Y
zm&Llex;EZjb&)T)`#sP5{qfD*oB8FOGrxQ8x%bRGXWZP30a*Y5Q~>}a34p|iB<`U9
z!V+REDVDtycgcU{zGneI`d=&|mV^JrTXuT?;w>)Q|H6*{Vr8-1>0b;L<DH;wKRx(c
zjCYCUTi*OG?sPH!hYtW0OXPoIn3%M<R34BP>#f9ix?B=~iZNS^XUgS)Eng<Yc(z>P
zC(ki4-a2G|o+m)l+XkiH07(+*lIfCdz!|YtARYoI9`c3)031~W0E7wvw5bDtoR&BW
zKTnM(zJDb{lI{QZ`VZs({~NBM)>W6}ym0><W##01vxWb)++qU&835R}#Vi4cr~Q+E
z%TW;UQW+#WTQ1fD(m(&#!ne!LlyBX$<L4CsDpE39A;W17ViSkafM6QKg$}i#@B#Ee
z{00!*qW~NV3?LV({|?ALm49WAUy#{n#=O0%P;qHjX1H9B|6k9pBc>olvc};ZGiiz<
zq;>}Q*bUd4+4_!vGvERoM=jW#UW#7oEIxn641_CXSk(RqUp(6Xq`LXRhl_QgX_Hsq
zrkVCDe*Fyj5)JQ^@)519oE8%I{30QV(DHb7eM4q=48?Uk8#-Uf-|zF|OW*VIN^cSL
zj@=M*<FmCf(_3D0pwLTs&CFzlx^x#=7FP%f%2~B)Jn}LvL+y&yk`7wnb-qVV>yJLB
zJcAfi`m}eSC~YpUck`4-$vpuULupCoWV@d3n;YOiRUfpf*Y0$^J(R0REEqxg(mptU
zyXWopM7oS5?e<7^zn?$I0A81=vX5;+eE3)UrJP=gr$_Nom}G9LAH<_oM*g9Eoy)CP
z@84HfKqYb#aI&9Z>RvPE_g4gh=P61RPocR-_eO1R#V;)@8u!l*sPwAnz}{-jNNkH)
z1ZKbI?PxoT*<)yP?4?HD=;xrhjl7qr2$z`WzR5nm@`;_-lCQ>-Z@#)tzf|_txmbG{
zfAaGw^&NRyW0en{FI6K4mnzI+KY!hh4RX1R1O2mhR3kvneNu(Sy?GD_l-u1Uno?-K
zb<S}N7pF4#d?axYBhkD-JU%y?roLNtB-?PcKCAeCS96BO_yVoLWgihfe9D+L97_2j
z&R;2zD(K)##l_1T)<4Rwe2Fk>8S`BPUm{)GeR5gS!*KN#Vdf+J`0@PVD($KRYnuz3
zdU~5pRzF-WXnu%`e{t!1$s=gWj;rbn3kmO2{61mXH@(ejXB;tgsAcxkr=<(u<X(|+
zABU{$3O8L)UHWVp!E3wS*U7ifaUh#U%TLD7xdscndwPs@<_~?ob*_f0@@A*Og_tQ$
zLVV(H?<7`(uA9of9RqipT-9^i{SGp*U0OH4O>X6t546w~F*mSpntQ<1hZSq=Ar!4g
z|2Ti~{eanK0PVpx>*q_{M@k<yT@l9$_7M|^HRig{-2O6>6n^m-y!s@xKymqr@<zk!
zx*wVa%bTD_@I875zrVUvyDDuSlE*C6j>&JLeDX}1oXqS#+E0`_=4{41b>^!}rc3cl
z&tF#C+oVP3=!~#cuVRNx-Ca_MSEYB%zpBEpJMd94FFa}{2YL=_U3#NoJ8rY8fw#>B
z)hh;s^l#X<b`!=hb<ex|Z;IBh&6Nr6U%h_U;^>>TnI9L|%CWkJH6D}MdYLayX4!}~
z4$e8YfM4HN4QIw~cvVG~z%3}S5Ciw`$2rZ&-)qYb#J*e9%udMOV;IC#usd_g^15DT
zZUgLC{qt_$;`8%aQJ{oU?U3!C*YJ?wo3?|W+K#y`j%p_6KOUr?Jg_rZ81Rm?FU5C6
z>eQ)o_1GIP&e2!G{&LmoxS4-Y^YqyZP4jo=&boxO%NAdR>PfI?Kze61IkaO{6^|b)
zN&yVuIahyYn_57z`{pCtn>*J<uDqUdN~r=%t)~akQ_#~z?(1w<TF-u*`^4lokX)gR
z`OW1;V8o+xVyI<|8hq>~{LqWokTs;6mB*QMDz6-g?}bUrYmj4y36;>}Qs$|1FRRhE
ztM`wdr^%47+^}Gsk%_f$96o@uW2}E=cPpLDS>CZ-dwEU$-PMv_T;)B>vjZWyb+V(R
zKaX_k78Oak>djGaW(*q9R`2@+>{8I#s2u22<Iser1?aa;`a$|`-q&ztqr<s$FJ^up
zr5jbDz%2~Qe#X7cTb4kUvuF%nTtbcgDhOwE#MJS4wdUgj@8fQd*Wez19z8^B&S*Y2
zHnH}@-{u$Zm2Upsybp`_6v4xKVLjEb$4{$d<`zh>6P$zJeM25!Hi4hn==mbv^pAgI
zUHhEe!SdwKAMP8IlZg<C{^RxjP5Jc92PyqS$DDK&KbNwqo>jJf@r`*sS|_C}UqvxJ
zyXp*Q#I0R8mA<E%)cyB@x?{Bo{dmY4*3~P(;KI!p$QutedXaXa(vGqBLf%-tBI?KY
z9Pk7v5I6I;Gb(`xzH{FMWgIeGj@r{_=*uV4^2xJm&Z%eQN8+q5<+IM);or`x9Q^(U
zPn3d$(;_~qI#^WpOTCyXC&{e+e(zVgMX)^%dU1xxi<7MR2-1M|OH^s(K7|?WQIWgy
zjFmN!^s4niMp5W;Z`Gnn>DPzcZZh)2TlcwDiT`M-&w{trZk7-s8vi`5u3-VWNM8-7
z!q$%<--%6nDxQotpWZ}ZZ@fk6^CS7h^=}IZV|Us&--dPQ(Mt6{o5Gu~-m`JA$44z2
ztVMAIzq;@8>%T8!^JUfp<OT`^{V`2ne?I(3!zCMQ-vx~uest*5fn!(CLDRIf3lhif
zJkp0Gy=e^EC7NK;*LA*k)BVG4Cw;8jm-nf~XZqc50rPFJ=yAv47@DZDd6;ptOUBWq
zWo&dC>ZRRp7FBJ}xd~nKZzmtIrbrwNrmpmeVbOI@Ic4t$OFji0QNo3kwWp(=?l+%~
zU3>re%9E5P=C1q?bqDwY@c^FI_4R2URsrksA<NyFr#rrMR(PLD9J^PL+BN@R{>}^e
z?<#YHW;66Z-ydr`n$%(2s%E=SGK${SJe^KUZ<V?5{=kE`!7Rw8#g*Y0ea5=oZS>(w
z;q0$nzceL(T?eZ!WnsGN4{6BuU3p@Hs2WG7rd>9nXVFSbnB$>xF}APQR!&6T(q0HX
zXq)1ApQ-;9x8{CEyDjl!+|ozt>cejB9T|5EwKMAVQY+pYL%f#)R6$Va%t}@V`SO#F
z*B2+P&4WWuTYvGWPc<nX%=_dXe7x4CRr!3-;V6BVb(_11`>d&qTVre4$l;W2*_A4|
z7aH~}P@6aEhSBs#xBp%oG@t3~YN!7G3Tt2<`D{*~gB*GXmO6FCDrmS(>yuOKnXwPg
ze)W2DH@1NNc#59=CfihafdA0zWv~ri>RbL->-8nZwXl(;kdye^pM#7b-)&m&OnG;u
z+(+1ITEDxcChS_Dc;@Q%;BvE@LBhwhJ1|x&Y7E9f*dDgaG&-fPof_Qn>CLMtPi?{d
z4=ZI-QXwqy`Xo*V#!Pu#o?r>yWa9@6ceu7!{pT@LbMx@!6FvL~^EY<n#4A;CnY6`~
z&-zD;_7c`!zqe|m905Y|3B#X%SOrcm{*s@08GSkQ!3xs#-uJh6U)5Bt8I5*-``q${
zF$i~Z=uUJKjuxbD0Fp*Z)Tvr)+VzD}{{D=3+QrfM+S1{HMvI2sC9Rb)ZlBeB4ts{V
zRhC%hqhCDymW%5<0jN0b7#}m^q|j40P6P@sT=_bTc5*1C(QYnW{U$1XTy3asp42`T
zbz0CjU!<!kLx=u8&$tnOrG#vlID(iOo^NS31NZ4ZmWK`KTX{O)lbtb=dbBq$rCBZA
zzqv<?g+N@Jr^5{sIT089{x;fJp8v}UxK{+LPzt_L`A}zG@HlZSs@HivQ|=fXm-2hB
z35JK`9M3C6Tab4wM{hT@%|MPSI^0DopV!K1w<KQI(qg&0KluLOkLi-WtcQOv?YS>u
z$JS2J6ykQAy8dvj+;%lATtBydPYp%Bo-zVq%{fUraWpBy>Laao7tV!DZeJ(Z+hAh%
z_&<hsx8LqNyJ0HzV)2IVi$8+>`>HN5x;q>7q}yiV-)dLkN{sJsFDCA_SCSLp5hpcP
zg$Hb}=`^e~J`)zgj}FpoW@n-n7eWpyAKR7Vc}DsrOy;13?7;a3^;-mq_~52FiJkIt
z%~WNk-ZOQFz;UyM3ri?|Qo|#Sdqbzno<Cti!`^l5c#g$Bv2(lJ{-f)+v0CUe+3E$l
zH{kcTj+$`QL0aWZ4Xlzl`i%p2JNw@9?&;mOZ|^kU(Rp)p*Kx3pb0ef(HRkF&4p%9B
z?Me_zfUwf`wYH72%4j*tSkV|*lzyt>d`at0byrZ0qG<r~X^hH1py@c_ywlh1uk9T8
zZiHL??{7I*5EYDSQ45-MKcvw`&Bd~Y7cg}C5a+9TG1CKhBxk&|LE<?zsx>*3O74(5
zR$8p*kBIntYAuO>;g@YX2F$?+8?Q9MZbw|x?XQM8oz|3%$j_aJS35nOOcXdaV<1WL
z+wkM^puhwL@O)CieW`2OcTZGY44r{S8joxK`837;u-&!Bm!N-(0R<Ugn|w%>L0BUU
zVD3SMRzrcv8WX<)UBEkAo6gq<7=<uKNkD;tZ?3jS8aR+|;Lg(s<Quwi!GXC3L3vQW
zOo$gx(>FuUGhN4vr%lf@bV~tyXX*sz8j7`Hg-CC%c0iVaQ?#l>go<Z^u1k!TYoeBW
zBE&DvFfhv~BA@7*sAIod#U)<Hk*V&_gFDA*n=xeVB9w!2jl44q(mEXId?=^QE=+{t
zwK<Hfq&X*o<7!Q#O9@$BHuOw={~R!MTv;77tMq|-Ughu2&2^dVKl}H7J{ci(RI9gQ
zo+16uy9lfXY=Z%SgoL=Zk_1%sfShWZtQOPUUaV-$GQG`2T*-pAR1yGzs6_KnEbVmR
zwwR{%nxu3fQ`(IHkObi6fvBwXO3T9Xgy;yNUUHiWuLsK?r-DG?Vc5EQ_o_WMdpaHB
z1kj{fbZjjwW)EcRE`39ws=-@WNp9??)pR+qg|PTCLv}4fT%CyvJ84BAugs>b&APn9
zOjt`SXdq=ZlXeTV#O0hZQJI}h6f~Jd<Z9$Jo2J#G^IA#Cb(o|&oVX~2p(To&9qaef
zg#G5JO&D=Y*n^0vgaz@n#TBCjfH#wG=yMl#U~~HjiS6jfT3CFOaeNb&)nKv>@CYz!
z8u6<dvEjBE2bF2LW-BpD4HzYcZfUCG;7BR~be6Gyk`Aw)94>-|m&1dEhF%%EzG-@a
znJ`I!v{Q9=HqMo;o>))z%u)|7hB|XpoKsZoBIRh2${;DgFAf=+4>OMfA{)^3Vy%D@
zZRQ?$Y!fcAkz^e!EsnCRJismTU{_kkHJfsVDC}N*&ZKQXrDk{oEJy?qyCa@HAO!$w
z0H@O~z6;|aR8ActMl?gkEwTlk&<O%$!2qkuD!j@tphzpE43g4KDV}wyJnor3VzyP>
z%K%OxTDfiZ`5pF|P1eWn*YNwi2CgNsn(;0^Rtq=V4_*~;%E^`ez6k<5PSvjTZoB*u
zCqSp)SJv(Cx_6)t64i6Ra?h|=#`Nab{eCljQ(DJmYD-EL1?vu(q4&wt#u+&}OEK+_
zyPuUP)W@rJncfLeKFs}Rs|D%;>Sl@cNV)(VTCUHmMz9+23;|rw<HIhq3CT3}=NUx`
z$?1(dZNrp_z7ozXt%N!XyBQf?0oh$);9H=T+(Px_YENA(I<j2XvY##J@E<;v%}B>2
zlv}&9bm=@4IY=U@37$}g2o>o?RHFRSA$V^IH<m$+z?xg>5?f#$kwfuJfF#vgMT>~O
z>2Ok@R7SgT(TH_SB_gB{?wP8yD^|-p86j>COm#*Unw|kS^#}0509^=;tiapGD5f=`
ziw3O%a<oDPh}}XIx51&LFEG2+wQ$@ewVSZJT0f=<>7K9bm@em2tQ}E@No&NVH<6e{
zsIWqe2S?L~2k}ZY@Mc4D2OKy(#DXdNtZ_^3fLUCtNmwI1ya^GQqZe0BaEeoLW@*?(
z%J0rIc8%8dNrVQZBFaaD@_L<_A~dhlDr3Ng)sBm3fxD%s(X$Qc*-#&zu9%!tYZqTk
z4N60iy(EJ&jr_CpU3n@20v$)5j7^G!*gn0-I=aR<v=qt^8c-OL79n!XLSx~OTXYqs
zV2qa7VZ!b+$(SJV#)-i-5c3ouZVxW32o^3vq_&zxl;MaBz{Ce|Vk?A{7_!?4+#X8J
zDWB~9W{E?_;tlIn1olbN7dzk)ryD0C<qpx<trXu3h!58wt7VsCl!`A0UcEmwx&aed
zsT1379NlUhQ%n-CxHUtL90+*isE89Hr~u)@)`}HT=ov;fyOn&>^uw!+A{*h3>C(PJ
zur*66tP<f@sN<9-M~MRPVE~>9gjJzT!vNbP*@${0X1xKs3mw}6vr7eh@>G(#@oA&x
zyip2wket8QHfPj|zu%rwt(P)H=8TisV@Te#abiD|zn@$<ZJje@&h9o59d^zfvxsSe
z7f#z|4B_Ki4I^40aRWw?gZe46$n-;K?ldf8(ug;NW|XVAX37T&waaEalUoT{17`ej
zOW}U2oc$CrGiTN$andm72)1~UDm+52IANDIY!X{Rphc?`^m*`_9qgjzytBa3jj)s<
zOxgr4bB0uZ#iQi7P4<3#`Eh$zC!%25rtv^*LAzggKG8eH&>~pgm80%ote!DJ5S?^P
z9>z3Y^k((Id4t&832I^&+A(A63uKg~-%-kcrCiz=nbil&9LEc$t@!&a^C!)7XDO+B
z(OI*E{5g_n)~tApoY{eA*J8s;kc1E*wTH?XAfyja1bc1g9`Qu;J9DPYQ%7(uSLk_D
zl<LEFl{1#5doB0_=KK+Rb~9;Lf_iK@Ib48`5fLlqe1l5#Y}hjHIbfG`Rq^99t_hhv
zN)k>`atBO>!`9p;DuE6n`bi-i0Ur)Lx!pXv5o;bN>C1;WB`dmRsySuIcnjrAW~_x{
z<~i-=oEjUC9Bq5HvWXuMz(@EMYqR?aab4KteiC<($Qw50jp3pi^_U_pUIQVc%07<o
zoY0GRFHm>Q)NsoN2UY1Yn_-UGQvT&?kqvs;<D{Iu<opS<tR8YgB_UZv!#HZi^cltW
zBbkkG_dEqpzLH;&T38i?UZn1orN}7IiV_*-^;%{1S*CT_r!={nG0+L4n1oSO;t-lM
zf=eAR;SS<6M~O+D#_W1bR=as*p+Pu*D<M5IF+oBnxEms>6O}ZEOBgfS+7RPL+-WRl
z(wIGHl-`HU>!TKQQ}SBvLo%(AJN30}U~1+V8}7EqR%FtsY2p|<X$liHqMtU8O`Sw>
zhtb?_OhyMjwcf@ez(n5~12)5}Q7Hi>5SL6<T8d)p`Dj)@E@l9cybm2WY>+l%k~D;l
zXhMZmSUSc#Xqp>?sRVTrh1X^2mjkg3lVu2z;@3)4D=e&0CwrQde~6kqj%D?lp@S7Q
z?ICIu6J=9VWh_3X3~lTMxFo50WoQNzXr{K|0`t{_gkVk|CTpCU(r4peXaS+2^eoMl
zF*qeOE~ndq+epmlu=L4P&FZ40Hkf3!QUi0r3C-|?4%66X2lHsGfdftrPf)`W6j4}C
zH!5d{AQ+}*cHj~!^@|5AD<>RNnla+o#&??0lFjt&QCl-5QB?6{Wh{Z)k1Uz76pWIq
zXY2*N<f;k#igDYNW>j(?hSh0@^xQI5A(Pa}RCOX%)s&PmLgEeLi>B;EllEmJw$&4k
zg?;9{R%}wMaa4_!jy+VBN)+3JDQ0Q}imD00w^+?1U%??2M9))V3N`XNhy~r$+-^#G
z2PvV!(ZC6#W=>T%qpFcfN?3xt5%&M4T;?`lUYb>hO{_x$X`NQ-?bbkCsaa?)6-X@g
zvJAum#x5q>mb&H`@qE-tNEK6(GQmg*hgT!wRS6{V@~Gg6U?N2gEA~Vgg;PSBDx>hK
z7`z(FR2(i%6DJp#nXQH~8H^$;!A%vRYU70BvrlDa&a#QhKQ=eHe=79IW>9rM{ixYo
KxLOFW68sNsT%)1@

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_ZSTD_tiled_separate.tif b/autotest/gcore/data/gtiff/rgbsmall_ZSTD_tiled_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..2cd4bb597f22b89233bece90c892928559910cb5
GIT binary patch
literal 6587
zcmZ`-cUTkI*S-l5ij>g11O%iLx-@}+p+o2`K<FtXq|gZj0-^Wbdy@`gSu3J~1zkk!
zy`ZRTcU^UL{l@Zpp4~sbndi*B_vFsax$n%m=bdqP*8@TT04V@qd;kU^Q^;Wd!f*)l
zLB7Y3@%{4SP5^-Th2fB2_80!%Pvu{J`(OC`xR_rU31R177zJS$7(Y;e&MHu+U6B7f
z{sXcA2!9`s4f(|jMSox}gt<kc00H^iAv|5e2T%|`3*ng(QSdz$5$G^m0{<~9rSA@C
z6Z)|af;QM9i~ybiGng670~`iZurpBm-H$dFRD%N86x6;2P%sG?7HB|MFF_W~4}d!K
zmj#ef1Oe!V2)if@fU*bxS0Uqx0^lPKz!YSC5&*12Qxt><^@i*wWOx}UDmehikYVKk
zNQ9=CrU<e8W0$*&`<Sen?C`(y&xrs3W2BsPM-2tLaO0Hur6Vsb7yj4t`)JVr0sut|
zgP4G5{W1P`B4FS#5+*cT0{sdQKibvXgoS2GzF)KD#~FZ9YHG9UAkz`*;y4@_>J;J{
zfZAcs20D9<zk<-){2(5hJ`CERqqMA{jZcJwn@3=no1i5jDn*_`iHXL`q(z2?TP22v
z#{h(@a~udF1Q<sX@%)5@T-Mf#ih^nwrMjs_tC~?$2usd%3vrFgqIr>FFvLK6Q+5G>
ziF6Nka%qaaIDV5;)iCrnKUK{KqBo1{bmI=Z5yS?tPXw!qNr-u=s-)xRPuwz<=v%hm
zqrRvm4gVP<bRV=sBWzLBaiESaSVb;qAmxNVg13Sv_{CkY^UiB$>)l*)!`A#gZrtz<
zzqC)8y4e~3`jt?)P`*=<OvX74T~FW!a3DBgc5^$fKo7NW+j{)8;=JxFdSKO!TN}9x
zl#VvzlK7E-UL}i#V=G32FG(A&R+PBMmMTkbSk)&Lt(oZ9?F}AT>6HOH;MEV;l~mDM
zyPnTP996mBg-8tCC+h9>s>eZC({6E?N{_qfAQfy?s+sW|#i@Gr=f!}lQ5_+7Tu7_I
z_YKypZ-q$xCOW@AyB~gTV~9_w<*VV5X0(b?GKwHCh2{ztac^9rSQ>4Hs2e|l@k!Mt
z$(U`HbboZnKOjS2neaM2(|fUVkDyqak$^q5N!B!sSgdYo$IA-rBQRfmu;!C6vSQf>
z#khwVPo5STpRn+*+vUFRuM2D664@q?mukOQwx>oTo8?10b~qiRT|}DguZl+4>%P?1
ze0}LP?cA`wot5HR*(2aAhI)-LvmJQdU+QjvwO&bFFj5#2`l~JtQ6+)AZEqy^^TwPP
z0|)|j2a5U-pj#!rr}eAjl8y2=-^@jq$My02&QbfV&Q!R4GRBaG4`KN`g|xQlBJKvk
zb$}>n%NL9QVIUe<1Y}^==id(NCW|kAdj0NlOH$VA?d{fIMQ$8fRFK%1M)>)p-Z;AR
zZ_%e&O(Ghb*Hf7d;ji{y)V5d-`}(&@)}BhNvw!Q6!;Q+zR4D^^d;Oc=*yy*G#u!n6
zO1<N@G1-SwjoXY9nf3H@oVj<OtNncL$;hbAc?)%IgHhV^y(#xs^72HjrW(WF+xs&Q
zUK*QtrXc0%Vbvp^aCB=%P{c(=KTFD+%VObr^HP?9PtJ8Z`C9JvXV2(P>S9mcGKrFY
zQZ`<H&F3`cLA&UkJ2FZ~80|V^Hy2<`yih^Eu+Kl&v4Y58{+Ay-!|KQvH~5On-nmHZ
z(mxW;^9eU_6n5A2i)BsVEyZtP-k$mpYwVpV(^sn^QS#y}78{4TpXYz^XoUz7^Vz(F
z(CBg5S6FHHmmKeMbEE2}(5r9KOyqnn<AN`C?-EwYPgV5q2iiB61yYZ?@}EdnevT&C
zmdsHVpDQU`YisNOL+ib@hSuu67he>5BOPo7f2IEsI5^1{h6hpM1V5jEkdQ!}XOM?`
zu%9>1%R9i`2k#T;?C9m{=HV9<?dIT$@yA;34EA9Lq~IAN*o4^h0Dsgd5}kK%BNmy*
z|Cf}wYc@P!@(Ae;%u(d$6Cx%E;<o^3)so6g&*HJZuUOCq<3l?Y(V0{#fO(fO8PUlM
zHh@LelvgEC;^VfKbLuO}iDX1}aS10kJwlJ17oEw>PNryZYdJI;F)kPeGp^%gkqC*2
zNdR~@l+%OVLPFg60{j_~k-^@$Akzppl2<4eyVD8yg<BB<0;A$dwlE<&IU$9d85kMt
z22v6|Y0=RHqEJ#~U>KEK#sbb+IcbO3eMznhdsE7YDXbhIg+dhy58L7WHPuchHL|ta
zOx2Qgu*(j|UWjHq`na&Xd`I1cTv@Om_H(8|!azof6c8Sj6p}{{^Cz(EO|V3AWCSkR
zYw|!--e3sPEx?RI43G9Rc8{aSM|)9Xai*ySabaG&e0&^30*s6U2=>f^!0-rqVMabJ
zBF+Qj8_i@z;XQr5eX>$=)9DHL$e;vg?9K=`-@uaWC`M{hw0l5+uWw3XuvxIbTOh_R
zniU%!V!k7a6PrsSr!qpVpi5}cCi>1{WO`)=DaG42(K8{7jPp&$;3{H+;$!1jwq~AD
z!LIQEcD|7W49*ts=WK3lj5o56jv~kJ^rbKv^qfp~2sMSwAhGi^$-K0<{M3Z#1Ok;s
zPi2I-1r;Z!vpJdM6jCOaQ_75Y%4O{IiKQ~rY6~+;l5*>FBYk$b`KR)d>ysE+Bn))>
z)$t-;|E7$Yl$OWN$)cs_@VIGYJerom%A4b5(wed>%8J-*@~-&ExYA%d57&@{3{Dn@
zjyBQsO^&s~IlDXi6ml|CJRS4{{m2Q)bOs{^;v|9S;pQG3h4Ck3Wagw3lXc_bqddI)
z@B!W-G1=)%swI&~N}<uyDCBfPWPn%jwipUAg+xywv$Auu!?YEo?FbYSC5B0((^F|X
zw#rHex;ix{#U&>&DbaY0ysQkv&pISH2A`3WoTMW!jYP)jxq1iEf`U`hss5@eNQq2(
zs&6_iJ%~t*w^Eaq7Ej5{OCxg2sI){U6<KL1B)u@NBCouZnw+F9D=8x*mC7jK6<6dl
zC^1S>l28Ynr(-}=c5W7ns3t8VEg||}%EaKn9G*l1OjbfT$y!fQSz1OCDIqQOePjtK
zX=!<V4LMl}aUeB{#;Vnxzz8Dquy;OxI|d`q`R{RR-|Q4zNcj1@b_syM?}`BiDGGT7
zD@a!Cief;SD&QLfWfh-LQfeZM59ylCsfC>Cxy9Tf?$)yGTyBv7wjhsN4&VsYBw{6`
zO17|gY{2i7U0DbdOU>_Yforw)bx!?|69SCZ!EqQ|r#`!@nU7T%MvdW5;N{1{;6kGV
zePvB>vEjMN#$vf%G@?vr!xA^Z;KSL3=XWi9@Uy#i?V9W%^Mhu0es6ASxf3(MRjuuo
z;syPT-B1i%35(r{thoZIIRk)lagQdvvj0OsWqSwVL~2M;G%aD5TmALfA@l2qeG7W{
zdt2X~ww2cb0*)@9+X#QE(Z9)S@c9E@5Db)0%8cT|P3Qzr`kUBr0z#JPQ|f>4)AYI=
z94JMcm<ZRo`BK$J2gY@KN%{C*;4<eH!2xFTr0DQJ2gM5Jrq$Yz`93;1UluUxHT<$7
zL#v%IReAgF=c4t?f!YnG{VJGu=Tok4JUf8fAeQSraq50Cemr@}U-t20+grVg0lSI>
z1;fGv*!m_L{2mdN%jK8%wKVD5G4MjTnci(?R5B$flvBA~Q%mFOwg=^_`P{(2HXat1
ze#{B`P+1V;^zbdIlm546amdUydVZvj+SA6FZ?vfg4-LgP@0ZmG{pR93!YgwdQ<kQw
z@#iR=b1q-ySUvwRdRa_GyXVkvlTpV`z7%9EPd^-wjEI@I;mb`}zI5wK_~Saw<(|%a
z_Z-e05q@YXFM50U%X^<<_2@#E{^j$v`=(q}Z1-Q!k(TPg4*J#7&tJ9>0sfLZoxO_8
z;Ej%G=O(^6*s0nqq%z@GnhS^n1S-WARdE0Yw1qCg6;D@71gSh|lv75!Xf-!BKOY`E
z@9XaFuI}FFJ;;nKS0t-Q9}7A?1_ua7_u72e=wdh|6e2;2U!K~LpyEP*uTya=_D6?~
zAMP)N9l{2g?houpsxb;Z)fFByy#MXhFMl39MJmFDQ}*6(zVNB6<&Mm$4^K{s2Vcn<
zYx!*}?a9%g^&PN}eo`BA^k#eY5`KV8e|AoDB)I~ImU$Cv`{r*In?8xvpx?T~9SADZ
z`$T)iiY`AGzkk~*q-=Km>J=iZitZCwlWlUh^pn|>75`_1C8eb|zTUeH&mraJ9WE?W
zweosCeaS1cxy>*2hGZY0mfZT)hqOV_n7FdsBy;5H_0f=|(sPN=oOCTz<vQbCD<0i>
zkABs+MQ!%}(^H4~--gRp-`8-iqx<}m^hMDUQ-bzew6}R-7&A`op0K+U_E&_iqjkPx
zJ9~>pjiHX$Yx--{e3q$_W2+lM)57t_*JR}@txb+6?$QI<^N%;_-!`9A?8)*HkNC{$
zYnk9z>0Me1CV;}iU6KJO9W@dpO*J=#iXJSkoiSfMB5P+;qwY;d+xg)o6Bn<y-I3s%
zTUk8#AF)tg52`9Eb2Hfag}GTwHiMp(oyJIIF|w&?`SkSIXkr|R#7xg2MI=Ts5<;T0
zQrp-qyi26&qK>r8e~SgLvv1sd33~q4DS{}0UnNu!tV3b}#-~!z)IHJyA-IWWdsBB?
zE8Mdzox^GA8U=8CZB=_-b#;|`U0H7jr?{G5ytt*Ux~?$~W|Gm6)mYtJQv=s&+}+#I
zP*uhTaJXepTTg3sLqi?3!UYZuwG?L*6*2*zL=vTzSHekUrU5>e403HcH-$<d2qfgh
z)Nu=|8tUUk3(6V?x+lu&co_oH?H!zf#>S?0m~44@L2>8op&__nSW8>Ojh^$30PefC
zQqr4O-Z=!Mdyz`_J;FX93x!W-;_D4#u%?!6Y2NRR_CKExxPnDI5wCsZ*Z12+WCZG8
zs-ZToq@pgbt2m9psmJ4zY8p#RbDQX=FHW@`WtAi`f*WdhWh|ehyt3R(Vl|Hy)H+m_
zPm51Zj!IAU59O4`HS}lZaq4=SM>{JTa#-A&`i6r16b6ah*EKoX*IeI_S(1=M$c`n^
zhP!#~eXUK@j0^^&n#=S~OK0RUs7+m!MVyeZ{DJb3ww|%kN@`UBuemtHmt5G=b#!WA
zpn$?n;0-jV(wkyZrs~RCo4NHNL77##WL|0nv%H?gNh-@{#^9sM@s!%yjwV`m=kRd<
z?%}D5fzgra-l^$<&ix||(*w;-ef_ihrY8nU(l|5CeWO!TBeN3+jvqKYSQ^{Y7@J-{
zFgA1U(A1&!={>DE)X)^}*pb20UHxMnssAm3KZMpu&*=2{#O&_bx!IAn>cX(DzP{bJ
z=O>5GP41uB-8a-oEXm`|6_PVqMGeDaeS-}FewdWj`UG}zS}JE|q_r}W?8oNzcJ%fS
zj@0w&%GuqyX&L2>86|b2yT`i9c$l8v`fPSVc|m$Eue+zCA!K-XV5qNuxV^SDpPiA$
zac>_PnH`;;=<n(2Y)*5rv!XW-k4z5DPYiap)dt#HS`?;HmwNlg2WJKvN)xRtOgl31
z9A0z%^uE#VPzQ4(gJN$=YHmvor)RV$-^p56r?b8-t)s3vtFf&y*3sBtd*{GlTUp;&
zV_$o+gQcmlLGR4)O!wGmV^6!6rJ0$D(NO>7#L!qzb91GGg_${8pPNI==CpNow$(XX
zS(+JW{g<*AFi17j)PVNZqO2fSYb#SzBebCj+SJ&@K!3Zou7QEGrQY^!C`dIR(YdQ}
zCdfQQ`nPYkWTO`SIj@horoXB#KbRMQ!~h%!^T}u#qBT^djkhBuO>``rt+s2bdFiOC
zZB^U3T|*Q4g0e+hUq?>N&_L06n}sgI-@(ku1mo(qB}f-*13a9Bm4twawVs4N^fr*_
z;b3GJiE}p5mVuJz`MgQ~z$D^?=JoS`ahIeo96k<Is$Cm)?}jbkuVEpFC2(8#e@1g^
z3$SbrHb+w)f_(BCuRvDZ1YOH3cKY<>#i<M8<@R2@Vyxlht>KkN7og%IOg*r1WohK{
z?&k2Xe7k@PRQn~bl==r3Ssgg(Xw^aKGPtgHCRSvi_2bU5=5ChX^}FOV7RRa6dp$AC
zjPe-qkOO84A-T81GBOZ+ac4FT+7>SLGF4x~nrMfPz2Wl|I{YL86_lp%a_3mKQmcpG
zb@Gwq_-){%SXn_zq*b`?i(?+%Zclx$y*HgtICb%6m5)~(h8UsxYTEmZ9KtfH^0R@T
zCSDKe($2qyPSkAe8$Av;8vl%;FYG`|RDEsmOjP6#I)KcYF9{X4IoIHh_CHXH^s9ZU
zP-hr9uiDJpLRlL-!{q<`)s83)Zxn9NXqH)X5^+%adQ$hS?$I6Y#@`;9E0|2Cy<C2L
zKtfNsT6|K-i&6+4t*DM}euZCiNRkTULs9jEmcH#Yot>#AZe{oJZ$Y7)H()1qc+}zY
z0=-R#9rQ-}iV!nI`hR5|5@84e(fD;T8L?2iXM4wK?KyV>#hsM-U_aQVQfVe^?moEK
ztm*#j#=&7yoZoiI4`$69dqbd7jtB3iM6{mIk}r0jG>TiD%bvY?Rx36}v?8|34x6a%
zc4|obpX?o~oT-+fl)RU9s}IND{{B=Y^txC~k?fUow`iK?FH_fXe_0-FitRssyR)j_
zY}=FL%zHb1)pkGn`p1smOxBmDdvYTO9vtTh$sWr7>-rlN3w<LQWGn7qrS;>p^B)uc
z)??FyZ0}}|+r&TLyL95!F)q&ZSpC`bVC^ox;`%B$!<L}^w=3gJ(R`SS{rn}^`4K(L
z{>_JB+2f;EM9<?N+Su#d-HrP;a^mf^NXiQgtdJ6_?R|+!2__ftM86R~ts7lq2WS{+
zhH5mB)*gTHFj-v{5<+{d4Z7#~3YR0~nms<gxWta0SLb1pC3Q|16dX5w7^>eMwif4N
z+GPEVMe<%c-M~Ud_qlB~T}_x-Y^+w&DOZarrD^<W?iR5Oes^htqb6bqOxe;-M+blt
zQNmIA*SlugX5TS>-+tN7VwvZ6w_#-Nvi*N*x0(jnj?!0F+^V6WrYNf>r;bvUS5Z<_
zmsLk;E2>FJDk~_cs%x1jNy=<f6hdmLIihxMcVx;Mq3yQHqDE1rYWFq}-(U34RgLsv
zd-`FfONAZ3zR`6dz*`YLJrq?HKwo+_@?`*m|Jf*vM$$~@-amw!bq^ohpgynZBFj1J
z>iv%LWOFuAHX`gg7%3Ew){r`5yWNk0GsX}F?tfT$DSjCtCRUQ`0`Qad-RwADC||d!
zkZ`_2vt)LylgaU{u&D#Y^Wl1d75VE|Iz?qlupJ>c;Iy1ON0jBy9Fxt#9G4ymUv%HM
z{w?Vr<3O7;*|T{u>%j<>$0If5cO8$v@k#X}yJKf^1kr`UdsXrNbH8I<Y*s#Oo<yJC
zIO|ILgefj6di)rLv--Kz91#L?{?3N47tSJ97LH|o5q&apa#^qh9^I6ipujcQ&zHH0
z({|AvZV?mS65jpsA+0Y`(F#}r3!o}kzEV8mube4AG_9`SdpWMbYO4X&%Jwnu5AEX;
zR7sX#D?mE}3!kgxT<%t7lXvglZQZA780KoI!0b$PcwNdcrtLJx1?ijZdlS3u>aLG3
z4J=0B(J~pD>%QEcZTbr6xapv45!a}C*~BaI?K&Rlp<RE-Os{#}^>VcGAO+qp)_i^4
z=5+32G-+PgdV1fftHqQ<+Le{f>(-y1ss%feTpu*{EuV2sE|!2Z2)!pym6_amDtxHR
z-ES$t;iX2kbmgV&Fm(r^vwmq8<`WYtvYMms(PaV-Xa46s-U8xB%0cViv$FubQlelf
zpC22xHZRdW{Al^1PFa1ThQr5a&L+0R^Ey}HmcSC?<(6+v;8w1icG60|23Ie?P1hG*
zU~=>83fW7fykI=|bC+Q@OPT1Cxr$%*wH$wO=l=Q6{>I8-j)yf{bKjhtFLSRvDuU?@
z4X#!S(c&2|@+OTDNVhSKC2oC8E#LmGTs;r``lH&h#dM)v`#Y;lW3rUn_u$%lv<e?;
zUR>UmO}HH|kS5JJ9+UuYIy%L8U%1AVeFiMXA_i90h3+=G91!^Z{qm0Ve_}5jcQnvA
zcAM2uVaamcWA&%n!|4?1p2VBfw8tN=Tun1gpD&8#T<W^;A3C6F`_VuL*g!JC+dyB}
zT-#L3*x1zE1Z`+!gm$$zGcy8`qe!>hnG><!EA8GtfB&38hO6lYXxCUTBW7g&5BXOq
AzW@LL

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_byte_LZW_predictor_2.tif b/autotest/gcore/data/gtiff/rgbsmall_byte_LZW_predictor_2.tif
new file mode 100644
index 0000000000000000000000000000000000000000..8f9e1ab953e9030901c0058842f4f31d003e2277
GIT binary patch
literal 6016
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
XF$TX5yB+V^`|fQ9_=B5lg&_Y64UZH5

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_uint16_LZW_predictor_2.tif b/autotest/gcore/data/gtiff/rgbsmall_uint16_LZW_predictor_2.tif
new file mode 100644
index 0000000000000000000000000000000000000000..0f1f48ed8f1f787f9e4b7632af0c207a0c1b59c1
GIT binary patch
literal 7306
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
Jz^z~~{{_S<KB)iz

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_uint32_LZW_predictor_2.tif b/autotest/gcore/data/gtiff/rgbsmall_uint32_LZW_predictor_2.tif
new file mode 100644
index 0000000000000000000000000000000000000000..e54a5a91ce016c49f2c0830c4a896657a82af844
GIT binary patch
literal 9261
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
aIbdGNSK(v6dAx=(;U=`F$NVr9%Kre_6N_g6

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_uint64_LZW_predictor_2.tif b/autotest/gcore/data/gtiff/rgbsmall_uint64_LZW_predictor_2.tif
new file mode 100644
index 0000000000000000000000000000000000000000..89506254f8dfbb282b79859ff8fbc31be91ab968
GIT binary patch
literal 11953
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
VIa-<f0xnyhz!X1O>IJaj{|n^2t1tin

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/stefan_full_greyalpha_byte_LZW_predictor_2.tif b/autotest/gcore/data/gtiff/stefan_full_greyalpha_byte_LZW_predictor_2.tif
new file mode 100644
index 0000000000000000000000000000000000000000..79747260c2e24448e3ed9964000c32938ca540e4
GIT binary patch
literal 15525
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/stefan_full_greyalpha_uint16_LZW_predictor_2.tif b/autotest/gcore/data/gtiff/stefan_full_greyalpha_uint16_LZW_predictor_2.tif
new file mode 100644
index 0000000000000000000000000000000000000000..f16e26e57f9929d7e79d8e32f3488a7ea0eaabe6
GIT binary patch
literal 20550
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/stefan_full_greyalpha_uint32_LZW_predictor_2.tif b/autotest/gcore/data/gtiff/stefan_full_greyalpha_uint32_LZW_predictor_2.tif
new file mode 100644
index 0000000000000000000000000000000000000000..de64da93b2252bd02e7093f4cb0b62775e555c19
GIT binary patch
literal 27155
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
N|6dh4|1XU`{{;)ZpU?mR

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/stefan_full_greyalpha_uint64_LZW_predictor_2.tif b/autotest/gcore/data/gtiff/stefan_full_greyalpha_uint64_LZW_predictor_2.tif
new file mode 100644
index 0000000000000000000000000000000000000000..6e1e476a85fd437e1da5512b0b815b39376c89e7
GIT binary patch
literal 35115
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
a)tc9T?wbBj7wP~1Isad;(Et6_`F{Y<A=R<~

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/stefan_full_rgba_LZW_predictor_2.tif b/autotest/gcore/data/gtiff/stefan_full_rgba_LZW_predictor_2.tif
new file mode 100644
index 0000000000000000000000000000000000000000..2e8d2fc2a50bfdde3e1a3f1a35af151a5993b811
GIT binary patch
literal 30723
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
AXaE2J

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/uint16_LZW_predictor_2.tif b/autotest/gcore/data/gtiff/uint16_LZW_predictor_2.tif
new file mode 100644
index 0000000000000000000000000000000000000000..b2b630ed7253404fcb3005e06b187463efc0c4cb
GIT binary patch
literal 802
zcmebD)MDUZU|<knU|?isU<9&6fS3`9%>-owRWL9^*{nb|8<Y*wBgn`C)>{PRh$4xL
zLD?WP#i4380M*DKsj-E!nSg47k;M6$c^H_1V&{OksfCAu4M;x&;`Qy!3<^M63~0{A
zb|wZHAUh1mMgTtt2pdKtWU#Ruo=G`^#Lvw00n;EhBiJ|W3=Av~Hqhx{F(#Ic?V=!g
zj*abX45AEdz@TGf=u>9k0ny<ZEMQtw+0W6%$Xr2RAvDBSp(;NwRl(5EuLdkw!_Xjg
z0O(p3hWGU?4gwn-7(e`PJ#^>&hZ9WdqMh~+CVcd<{8!B2w5Y&ib?rYR2IEByoF+nI
zFX}rS_{;xDDeKhtIS6rtn8};8pG-5%@HzYM!_-3$1$NZ@{5ORmNNvg~9leJC%bha?
zZcdKdz|eK%p@#!Q0;9q5phbcbxvl@S7)+OK@rVgKs}^@9x6mSHR;ut4*F=HU#<Ks@
z+7B&ES-@2K@95_Jj|zS*{nhK(AD>a|VNw>#zryvo_%9u$?TXF&Uv6J*a$pHVc=-9k
z7a>a0YzL2I6+|8pnwWMc>fwtMy;at6O<_w5txhoKyDf24JHV}SFVkSAucqL&n(VnN
zW_s;1uD*6I-(zObXA_S=4u*YO&p!M+H~4R~%e$Kk>#QA^<CfTQWUc5^=P&YEp~-QI
zV}@exr?$z;D`tDV(KxZX?c!1`tvM|UXPh6sU$^1#u9+fhy`&~PY9}3Fu;jiZ@qXKy
zNp0=xwVZqfmU;v|X;$c%y==Lfr_rsB$rGdYd{~#6z3<)PwZ8*dS7bkl_|3qRB=v6E
n#mSeZ?&atbXkY%yde6scE4tOzFMF|iSCh&~5xdztJ+hbpXP4#*

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/uint32_LZW_predictor_2.tif b/autotest/gcore/data/gtiff/uint32_LZW_predictor_2.tif
new file mode 100644
index 0000000000000000000000000000000000000000..0f667d0cb56b96441574a4b686046d8396e594d2
GIT binary patch
literal 912
zcmebD)MDUZU|<knU|?isU<9&6fS3`9%>-pD0L7W1Y*rwf4ax@T5oBZm>n#FuM3KbB
zplpzt;!rhmObiS%NNQ}MY@jehFp@Z5GY<nZQ0yEKH?{CEumS03K)k-4nLz<aivjK0
z*v`Zt17wGR903P@4iF}chD%^&I6RYb1WBBk=L4oeY(}te*cljDAZ(!1!D37-8{0)e
z@*Er6*%(9_*nmOD$k3<EzyqSgGg!d1rm~--i;=m4zCvh-uR>LRUaEqjp<fMHu!f;Q
z>VSX&&_A5b*7rYb=#i4)Xtq<#|50LjUYO_Lq7OUHgfL3iA519Jh*+j9Y<Y0u21}L>
zMp*{)N68w-R)%adot|EJ?&9OjR(<55;ER%{|16um5{fpkIJpZiIP|3dXRB1bPUmGU
z{qHUJY`IzwuPS-K>Z{4N?$GNpt+PVglP4c~Gj00cN$VK0kGz@8$!f^S#^bnryLL~I
zu<)YbgzG0}tm3)0&~2l{9+pRHd$**#7L(bc_g-O_j}HH@G&Z*5oiEpHyYW$rXKv@l
zf<Q}Fznk2v1C&ZF+iqL^-+k>x0;dUIZcyjV&!xWq>LVB~-qo3MR`w8k$<>7WPc@8o
zePy$KST*;DJioh7d(?wFRwlbQzCQe1^TU=@q0g$#wNDJP=T_N$GR;w9+hmb->&0}7
zjG})>7G&Mt@?cT+;w}cs7qensE;zlrZ=KVH<aM2U3_iWsy(M=y&(oDnLOk)t0ZGd_
zEIA^hPAV3x61%E+!8)Chf$xc3>(Pl%d{!RHG6`v1aV~&im(qn-Y;P6M7uDQ9l*v4&
z_2An}7Kiq2a#{A+^0m^ki#u|IYx;FMidO3%nw;qMW8K<6GZyLRpP8$AbhU~><Cdb$
zTxZ;$|LQeWTUV{nx+Am5k!636*1N@iD?VDBQpmqza^m#Kt5S`}j{i~nzB0ooR%d5M
z@mI+Oxg~7P!Am!1nwey_xGl0;dut)bxsR9FqE_^-VK}l(<W<aK%}y3u6Jx_iOaQ8r
BABF$`

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/uint64_LZW_predictor_2.tif b/autotest/gcore/data/gtiff/uint64_LZW_predictor_2.tif
new file mode 100644
index 0000000000000000000000000000000000000000..c3540d5ed7487254362257b5bd2501b114eb4236
GIT binary patch
literal 1025
zcmebD)MDUZU|<knU|?isU<9&6fS3`9%>-pT0L7W1Y*rwf4ax@T5oBZm>n#FuM3KbB
zplpzt;!rjHObiS%NNQ}MY@jehFp@Z5GY<nZQ0yEKH?{CEumS03K)k-4nLz<aivjK0
z*v`Zt17wGR903P@4iF}chD%^&I6RYb1WBBk=L4oeY(}te*cljDAZ(!1!D37-8{0)e
z@*Er6*%(9_*nmOD$k3<EzyqSgGg!d1rm~--i;=m4zCvh-uR>LRUaEqjp<fMHu!f;Q
z>VSZS0)rxJ6H}sqdG$Y8{`!{0LJJ8cwI3bMk0!d?q{&Ej9#6i+aYxBjviZ<s!G}I^
zHvcV;JPO!p;}py>$w~Ut$0@#Z_2(Q+FMPRY8rzHM9ZC6>HCnxH3y--QTK4Frb98$x
z{c_^VI%CJCkR*|nOZKg2UFQ}j!c`+AE!P#kNOXqlDY+?~w;o@c(R%D`ZsUE$?-`|+
zxLfKUE||XJoECdZi|NxJ4_KSnP1|oi=<t}4r0&t5YAEPklg=pG`Lsc@qhOWVwPhz#
zKl+AMi6^zM&$qUndPsdody2xY<Nu5lS6w<{9ALXev0wk$!}mX!LVT_Dlb%2Q<14ev
z_CWoI1v50tltb^{zLZ%l5wlI)e%<N!Vv%zHuYT$IbU<cCy_DQ3d;iC$PHxZmyr{{9
z<HVBAsTY*QY<HhOrOs%mF>6kXQ~xE6Px3F8=q*%zr7iZt>B8)awaQ15{Z6WO%!!zy
zl(YCx|MoRGN;{7kYKil?rT=khJp9Vo;_}{%FG3qntPYC%uE<v7EVJsw>?4i)gn~Mi
z99EoB)KL_Cv+VDY*J}<v+?C<b(mDOI%nk-ap+6Q!L^rNdRChRQQ!U>hWc{!6U`9-}
z$rfE}fg_$1nQV>sYJ7gKch+amyw>v`MVdC==eI=t@f0~E@3F_oyI*?Y$55f3)1OvP
z)$sB7qN%WRDyz!nO}$HXgOrMwX0%S(Xv!S8NbpU^Dbv8JT%Gk>owymoJx+J(Z{)r5
zXZjw|$@h&GtZlLlQ@A`yK1Zon_}yH`lZXBMObtu-HC?%OH$8D-&eEKYfQ>S*H5L{h
zwbb9yv9zWAoJREOvTG|VbKc&0U34>j@ulA$(=TM*inqSeQS%{c%e$wCO*ie}Ss!O?
Pb~V07W#crxCItlmqp(xO

literal 0
HcmV?d00001


From 1c7ea6a9219d5201625d5abc774137567274448b Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Mon, 16 Dec 2024 01:00:27 +0100
Subject: [PATCH 05/40] Add LIBERTIFF driver: native thread-safe read-only
 GeoTIFF reader

This driver is based on the libertiff library for IFD and tag parsing.
It uses in a very controlled (and isolated) way internal libtiff LZW,
PackBits and LERC codecs (even if using external libtiff for the GTiff
driver). For Deflate/GZip, LZMA, ZSTD, it defers to GDAL
cpl_compressor.h API. For JPEG, WEBP, JPEGXL, it uses the corresponding
GDAL drivers to open strip/tile blobs as temporary datasets.

Note that at current time the driver isn't necessarily optimized to
minimize the number of network requests for COG layout.

The driver supports most TIFF formulations, but not necessarily the most
exotic ones that the GTiff libtiff based might support. In particular it
does not support non-power-of-two BitsPerSample value (could be added
with extra coding). On the plus side, JPEGXL is supported as soon as the
JPEGXL driver is available at runtime (contrary to the GTiff driver which requires
using internal libtiff since the tif_jxl.c codec hasn't been upstreamed
to libtiff yet).

As noted in the documentation, no side-car file at all are currently
used by this driver.
---
 .../expected_gdalinfo_formats.txt             |    1 +
 ...indows_conda_expected_gdalinfo_formats.txt |    1 +
 alg/gdal_interpolateatpoint.h                 |   13 +-
 .../gcore/data/gtiff/byte_coord_epoch.tif     |  Bin 0 -> 1128 bytes
 .../gcore/data/gtiff/cint32_big_endian.tif    |  Bin 0 -> 3558 bytes
 .../gcore/data/gtiff/int16_big_endian.tif     |  Bin 0 -> 1158 bytes
 autotest/gcore/data/gtiff/miniswhite.tif      |  Bin 0 -> 147 bytes
 .../gcore/data/gtiff/non_square_pixels.tif    |  Bin 0 -> 244 bytes
 ...bsmall_int16_bigendian_lzw_predictor_2.tif |  Bin 0 -> 7262 bytes
 .../gcore/data/gtiff/sparse_nodata_one.tif    |  Bin 0 -> 158 bytes
 .../gcore/data/gtiff/sparse_tiled_contig.tif  |  Bin 0 -> 206 bytes
 .../data/gtiff/sparse_tiled_separate.tif      |  Bin 0 -> 254 bytes
 autotest/gcore/libertiff.py                   |  850 +++++
 autotest/pymod/gdaltest.py                    |    8 +
 doc/source/drivers/raster/gtiff.rst           |    3 +
 doc/source/drivers/raster/index.rst           |    1 +
 doc/source/drivers/raster/libertiff.rst       |   36 +
 frmts/CMakeLists.txt                          |    1 +
 frmts/drivers.ini                             |    1 +
 frmts/gdalallregister.cpp                     |    4 +
 frmts/gtiff/libtiff/tif_lerc.c                |   54 +-
 frmts/gtiff/libtiff/tif_lzw.c                 |   11 +-
 frmts/gtiff/libtiff/tif_packbits.c            |    8 +-
 frmts/libertiff/CMakeLists.txt                |   46 +
 frmts/libertiff/libertiffdataset.cpp          | 3379 +++++++++++++++++
 frmts/libertiff/libtiff_codecs.h              |  180 +
 gcore/gdal_frmts.h                            |    1 +
 gcore/gdal_priv.h                             |   12 +
 gcore/gdalallvalidmaskband.cpp                |   27 +
 .../validate_cloud_optimized_geotiff.py       |    2 +-
 third_party/libertiff/libertiff.hpp           |   96 +-
 31 files changed, 4697 insertions(+), 38 deletions(-)
 create mode 100644 autotest/gcore/data/gtiff/byte_coord_epoch.tif
 create mode 100644 autotest/gcore/data/gtiff/cint32_big_endian.tif
 create mode 100644 autotest/gcore/data/gtiff/int16_big_endian.tif
 create mode 100644 autotest/gcore/data/gtiff/miniswhite.tif
 create mode 100644 autotest/gcore/data/gtiff/non_square_pixels.tif
 create mode 100644 autotest/gcore/data/gtiff/rgbsmall_int16_bigendian_lzw_predictor_2.tif
 create mode 100644 autotest/gcore/data/gtiff/sparse_nodata_one.tif
 create mode 100644 autotest/gcore/data/gtiff/sparse_tiled_contig.tif
 create mode 100644 autotest/gcore/data/gtiff/sparse_tiled_separate.tif
 create mode 100755 autotest/gcore/libertiff.py
 create mode 100644 doc/source/drivers/raster/libertiff.rst
 create mode 100644 frmts/libertiff/CMakeLists.txt
 create mode 100644 frmts/libertiff/libertiffdataset.cpp
 create mode 100644 frmts/libertiff/libtiff_codecs.h

diff --git a/.github/workflows/ubuntu_24.04/expected_gdalinfo_formats.txt b/.github/workflows/ubuntu_24.04/expected_gdalinfo_formats.txt
index 396d0730f97e..db8d5841a8e3 100644
--- a/.github/workflows/ubuntu_24.04/expected_gdalinfo_formats.txt
+++ b/.github/workflows/ubuntu_24.04/expected_gdalinfo_formats.txt
@@ -5,6 +5,7 @@ Supported Formats: (ro:read-only, rw:read-write, +:update, v:virtual-I/O s:subda
   SNAP_TIFF -raster- (rov): Sentinel Application Processing GeoTIFF
   GTiff -raster- (rw+vs): GeoTIFF (*.tif, *.tiff)
   COG -raster- (wv): Cloud optimized GeoTIFF generator (*.tif, *.tiff)
+  LIBERTIFF -raster- (rov): GeoTIFF (using LIBERTIFF library) (*.tif, *.tiff)
   NITF -raster- (rw+vs): National Imagery Transmission Format (*.ntf)
   RPFTOC -raster- (rovs): Raster Product Format TOC format (*.toc)
   ECRGTOC -raster- (rovs): ECRG TOC format (*.xml)
diff --git a/.github/workflows/windows_conda_expected_gdalinfo_formats.txt b/.github/workflows/windows_conda_expected_gdalinfo_formats.txt
index f37c96eec515..5b0cb5089e3d 100644
--- a/.github/workflows/windows_conda_expected_gdalinfo_formats.txt
+++ b/.github/workflows/windows_conda_expected_gdalinfo_formats.txt
@@ -5,6 +5,7 @@ Supported Formats: (ro:read-only, rw:read-write, +:update, v:virtual-I/O s:subda
   SNAP_TIFF -raster- (rov): Sentinel Application Processing GeoTIFF
   GTiff -raster- (rw+vs): GeoTIFF (*.tif, *.tiff)
   COG -raster- (wv): Cloud optimized GeoTIFF generator (*.tif, *.tiff)
+  LIBERTIFF -raster- (rov): GeoTIFF (using LIBERTIFF library) (*.tif, *.tiff)
   NITF -raster- (rw+vs): National Imagery Transmission Format (*.ntf)
   RPFTOC -raster- (rovs): Raster Product Format TOC format (*.toc)
   ECRGTOC -raster- (rovs): ECRG TOC format (*.xml)
diff --git a/alg/gdal_interpolateatpoint.h b/alg/gdal_interpolateatpoint.h
index e92deaf7683e..735265dea43f 100644
--- a/alg/gdal_interpolateatpoint.h
+++ b/alg/gdal_interpolateatpoint.h
@@ -28,17 +28,18 @@
 using DoublePointsCache =
     lru11::Cache<uint64_t, std::shared_ptr<std::vector<double>>>;
 
-class GDALDoublePointsCache
+class CPL_DLL GDALDoublePointsCache
 {
   public:
     std::unique_ptr<DoublePointsCache> cache{};
 };
 
-bool GDALInterpolateAtPoint(GDALRasterBand *pBand,
-                            GDALRIOResampleAlg eResampleAlg,
-                            std::unique_ptr<DoublePointsCache> &cache,
-                            const double dfXIn, const double dfYIn,
-                            double *pdfOutputReal, double *pdfOutputImag);
+bool CPL_DLL GDALInterpolateAtPoint(GDALRasterBand *pBand,
+                                    GDALRIOResampleAlg eResampleAlg,
+                                    std::unique_ptr<DoublePointsCache> &cache,
+                                    const double dfXIn, const double dfYIn,
+                                    double *pdfOutputReal,
+                                    double *pdfOutputImag);
 
 /*! @endcond */
 
diff --git a/autotest/gcore/data/gtiff/byte_coord_epoch.tif b/autotest/gcore/data/gtiff/byte_coord_epoch.tif
new file mode 100644
index 0000000000000000000000000000000000000000..89b20114959f3f96b8d6c786904f33affcdcbc24
GIT binary patch
literal 1128
zcma)4&ubGw6rTJb6bVA1RgfN*wii9LNo<n}v2<yItTaJPS|yhf#z0}(D!iVY9z-AH
zGDr_|T=e1|7h5nld-Ntfi+_Osf=B&klR|=Gond+3zW2TFeKWg3a7RoDA*O{$Wkd>S
z22W}Xr$^YaG9&DGxiLJQ$|k+v(n8FR<!_9z)4Vz2oS=DbjMEy!*Wctt2HZvHyym>f
z0at-P_A_D;cpvz*pHF6e0zT`f#T@dVfnR+{ivZf+@$OdjLCxQ4^p3jEx<}phYo1pP
zj(P{)VfUbSf4<fB+d-=xY_@hA{?nkb-I({Nd+=f(wZi;*X?3-_?CAgMtNYD~redkQ
zR4M;QW6=C#U}fdXd98M>R^OSJSSl^uE3K_m3Tt=Q%9Zk!5<C7@P}_Y}f4o_5wkMQ|
zg~DZbb$RmQhPNq1b7P1u<7NKuapT7=-&MZ8+e)ItspPxiKgtd<euyNO&YtyWU481T
zpA)kp2TDr3T@ZN}pX_CmczZ$2oc8g7hwJ41M$@mAD&DfU-EMd<pC9(TVzGIgB#(vC
zOw5Lv6*enPp(O-M5gDbmWR02(2^@`#A=cm#DN>fTMzbbtMOG1t96B)~(pE>BmEusJ
z$Fa3!(MKFg*K(o0#MT&wI)Uzn#2O68GSFhkODzWyewY%ATC+sXO*TdviIEHsC~BO+
zE$3BP6ikei9zF&ZsiR_r<)+0}x{6fiv4WH|DmK=gTSA?sfdSCqO_>hlJFtthIAf9{
z8*0c9hD+&8b~K&G#ze#&Ngd>%fXfL7Z~(XZAq<<4BN&c<{<>ggwB;zWxJrdR7=$(q
M!vVV+cZ;O@4G;H4=Kufz

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/cint32_big_endian.tif b/autotest/gcore/data/gtiff/cint32_big_endian.tif
new file mode 100644
index 0000000000000000000000000000000000000000..ed3e7b326a64b7de101f1edc0bfa25f0e731ffd4
GIT binary patch
literal 3558
zcma*pF>6#&5C!0SH*phWQ3N-Fq<D}@8;OnWE?5P38x_G;6hY9!PE&{m(ukF%*jb8L
zSlS47;t%i#_!lho-k1B~I`D`o_S~5{bLPz5x4T&^(#4e0W;&fyS}UiV&X$+Favrtw
ztmN0)xsdaC<$NZs_q{3K%hQ$oRy$YCb2yV{d3%L(y`4{_^x{;S6rJkh%fa*hJTB)S
zhadV}S5!_OeoUj1+b-w5f@!v_uYd6<8h)Lh|2eDG`L(y-{$b^^drBL1k#frGHL5r&
z6Q|{ha=~$$ZdONm=T$YD^8H(re)F9R%lXyISGr5x%^QpE$)ksNyWQR8exKa0%m?+Q
z{5?H_bkOi|h~-}n<kjg7#W8QLd2gEj>j5A1^+n#h(8q7=(|;%IBhP0<d_MWcGfzwp
zPn{pJdhElKhxiaL#_mTSKM-FX#`;hk=b9JuLwlO%KE?QA$Ztgc%olqe#B}(B@_gWb
zZqLX2faXAc#QLK?UYzH-(ieI7-<uD*Uk7}-Kd9dvahw<Vctd^a?kDQS`w-httj~P0
zJ@L&G$2y<-#h=<eiS^;pi~8y@FNSzf-aPu^$Ww>>xeus6#`@^$=R=GaV}1ByJhA$5
zh|e#+JYDZU9)EcDjL(;Tyomo>ryu+IfVacvjvsS|&|YzWx^&__L_hT9>B`6NDS30C
zyng%3^CQm}{}4a=p=+L4pO`+LIZ;oaJf42Yk2t<x=HRLGLmw}qI^+XSOpkBBKkD)K
zg`bFY?L${y4E3v<FSalL^6|Mb5Au&sm!A3RF|W>_n2uOo9=b2z-+Xya?SoH`ANBr!
z^70v$$5W?k9zFZ3L;ZaGYTpmP8~UB5V?X`odM@zHgX;S5^wS-R-5azYU2#Nw^YGoD
Ny!pqWKKIu1{{V4b;E4bL

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/int16_big_endian.tif b/autotest/gcore/data/gtiff/int16_big_endian.tif
new file mode 100644
index 0000000000000000000000000000000000000000..3ba26c493cff7d9a43923059f3f47dde57ef0b49
GIT binary patch
literal 1158
zcmZ{iF>6#&5QXRNhBbr`6<h-$#e-DZNYdD5!78}hBq6ZvLlFX6Y?qhHJV^7fdgWrb
z<suea+6Z=%AK(x0FIejNX7;jc5iWD@yt!x2oSAorLwjy!oAxl7b>$^{qAjiYou&Us
z@$S+WIQ7>2$F||QmfoiRTKwtKhjTY$x<%Sw!<;Vtj@iwQZHosT-|LU=_vHV&{o=7g
zEL*o<O-S39f1=ZlN9?OJzV6=#d%usl9lZYh^FLHl?`98ZL|)q9i?gGOeT^vT>{)*k
zMd{!ZLM^?!*!Ip3o{a{tj$Rfoiu1E!arNQ-o8s_rbnU@wvrDV2wu!8^#`jvWF!oA!
zQ)?Z;7v4<P_+4eCurRPnAz^}tJTQ$%D(9rmL>|^U1{9f`VcfQkiOgD@SsB^jTG>p7
zKD18df3vw(t3`g)gL^7fxyqf;KOEJ##?X$=P#>Ml9S=w5YMc+YP!D5i3t7yE_-cxk
z`=w&wa?eyO-N43#gAEK3&b;zmnG;NvGSLN!wK~y8e-j%kI+w-Dy)hGXL=K9X6jP=;
zipXk&qBgvxS0ta?m}aoG`i_4}E%L|0M0GUgiGiMpk^d5Em~l)51u@C7XQBpH-c;>;
zbb<!dp@CWP9~VL~17cJ=(N6V7chrjs&+U)>wL3+4dnn=#HSsFx5L;;RuBW~hLghD}
ICkXrHKZ2p(?EnA(

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/miniswhite.tif b/autotest/gcore/data/gtiff/miniswhite.tif
new file mode 100644
index 0000000000000000000000000000000000000000..7eac54b3b847526cb3877c7ba8d841930648a429
GIT binary patch
literal 147
zcmebD)MDUZU|`^8U|?isU<9(j7>Uh<#AZffvq9NFEewK;EMR?;fNW7DHDX9?ai|)Q
O`7%i2!ANY7SquQsoC0zH

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/non_square_pixels.tif b/autotest/gcore/data/gtiff/non_square_pixels.tif
new file mode 100644
index 0000000000000000000000000000000000000000..41d49c3d4959806ef5652770b5540bb5eac0cfb1
GIT binary patch
literal 244
zcmebD)MDUZU|`^7U|?isU<9(j7|Lb>@|mD)kSb;*HEc+1K}Hs^zE40kqDbOmP&UXM
zai|&)TLwu@FcO=unTLTHD8CAbn_74n*nspQAVz=>_7L_1D2<T8!E%6zdqQat4*<c$
B2^s(Z

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/rgbsmall_int16_bigendian_lzw_predictor_2.tif b/autotest/gcore/data/gtiff/rgbsmall_int16_bigendian_lzw_predictor_2.tif
new file mode 100644
index 0000000000000000000000000000000000000000..a34e9d386f5213255aab9401ae6bc4d9fd60067b
GIT binary patch
literal 7262
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

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/sparse_nodata_one.tif b/autotest/gcore/data/gtiff/sparse_nodata_one.tif
new file mode 100644
index 0000000000000000000000000000000000000000..cf7f3acd65dd56d4470ba71b0a3448fe5779efca
GIT binary patch
literal 158
zcmebD)MDUZU|`^3U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1{nn7(|i8#gN$INNQw|
U#DkI8jZ2sqn1E&&f(!xz0M$GLLI3~&

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/sparse_tiled_contig.tif b/autotest/gcore/data/gtiff/sparse_tiled_contig.tif
new file mode 100644
index 0000000000000000000000000000000000000000..65558a65b933c10a9eba437f56cf8ba9141d2ff5
GIT binary patch
literal 206
zcmebD)MDUZU|`^7U|?isU<9%>fS3`=76r1IfNW+Uy$Xn#q2eHQY*026kSz*jgVf0&
zsd0j`6@cQ-P__V&?ZU{yzyhRq0I@4j9K_xL#KAx|$cz&}+_;2^0c5rz5Q6{*7(&>X
KBqPx6j0^zm3kP}t

literal 0
HcmV?d00001

diff --git a/autotest/gcore/data/gtiff/sparse_tiled_separate.tif b/autotest/gcore/data/gtiff/sparse_tiled_separate.tif
new file mode 100644
index 0000000000000000000000000000000000000000..42672bd1a55deb60620401165ba42d79aa9a6f15
GIT binary patch
literal 254
zcmebD)MDUZU|`^7U|?isU<9%>fS3`=76r1IfNW+Uy$Xn#q2eHQY*026kSz*jgVf0&
zi912r3P5pZC|dx?c41^;-~rMnfY=o%4q|Tr;$R>fWX2C5Zd}5|05aPUh(Uk@3?XdF
KNk*Vw85sa}eFw_`

literal 0
HcmV?d00001

diff --git a/autotest/gcore/libertiff.py b/autotest/gcore/libertiff.py
new file mode 100755
index 000000000000..3b5c09da92c4
--- /dev/null
+++ b/autotest/gcore/libertiff.py
@@ -0,0 +1,850 @@
+#!/usr/bin/env pytest
+# -*- coding: utf-8 -*-
+###############################################################################
+# Project:  GDAL/OGR Test Suite
+# Purpose:  Test LIBERTIFF driver
+# Author:   Even Rouault <even dot rouault at spatialys.com>
+#
+###############################################################################
+# Copyright (c) 2024, Even Rouault <even dot rouault at spatialys.com>
+#
+# SPDX-License-Identifier: MIT
+###############################################################################
+
+import glob
+import math
+import os
+import threading
+
+import gdaltest
+import pytest
+
+from osgeo import gdal
+
+pytestmark = pytest.mark.require_driver("LIBERTIFF")
+
+
+def libertiff_open(filename):
+    return gdal.OpenEx(filename, allowed_drivers=["LIBERTIFF"])
+
+
+def test_libertiff_basic():
+    ds = libertiff_open("data/byte.tif")
+    assert ds.GetMetadataItem("AREA_OR_POINT") == "Area"
+    assert ds.GetSpatialRef().GetAuthorityCode(None) == "26711"
+    assert ds.GetGeoTransform() == pytest.approx(
+        (440720.0, 60.0, 0.0, 3751320.0, 0.0, -60.0)
+    )
+    assert ds.GetGCPCount() == 0
+    assert ds.GetGCPSpatialRef() is None
+    assert len(ds.GetGCPs()) == 0
+    assert ds.GetRasterBand(1).GetColorInterpretation() == gdal.GCI_GrayIndex
+    assert ds.GetRasterBand(1).GetColorTable() is None
+    assert ds.GetRasterBand(1).GetMaskFlags() == gdal.GMF_ALL_VALID
+    assert ds.GetRasterBand(1).GetMaskBand().ComputeRasterMinMax() == (255, 255)
+    assert ds.GetRasterBand(1).GetNoDataValue() is None
+    assert ds.GetRasterBand(1).GetOffset() is None
+    assert ds.GetRasterBand(1).GetScale() is None
+    assert ds.GetRasterBand(1).GetDescription() == ""
+    assert ds.GetRasterBand(1).GetUnitType() == ""
+    assert ds.GetRasterBand(1).GetMetadataItem("JPEGTABLES", "TIFF") is None
+    assert ds.GetRasterBand(1).GetMetadataItem("IFD_OFFSET", "TIFF") == "408"
+    assert ds.GetRasterBand(1).GetMetadataItem("BLOCK_OFFSET_0_0", "TIFF") == "8"
+    assert ds.GetRasterBand(1).GetMetadataItem("BLOCK_OFFSET_0_1", "TIFF") is None
+    assert ds.GetRasterBand(1).GetMetadataItem("BLOCK_OFFSET_1_0", "TIFF") is None
+    assert ds.GetRasterBand(1).GetMetadataItem("BLOCK_SIZE_0_0", "TIFF") == "400"
+    assert ds.GetRasterBand(1).GetMetadataItem("BLOCK_SIZE_0_1", "TIFF") is None
+    assert ds.GetRasterBand(1).GetMetadataItem("BLOCK_SIZE_1_0", "TIFF") is None
+    assert (
+        ds.GetRasterBand(1).InterpolateAtPoint(0, 0, gdal.GRIORA_NearestNeighbour)
+        == 107.0
+    )
+    with pytest.raises(Exception):
+        ds.GetRasterBand(1).Fill(0)
+
+
+@pytest.mark.require_driver("GTiff")
+def test_libertiff_basic_compare_gtiff():
+    ds = libertiff_open("data/byte.tif")
+    ds_ref = gdal.OpenEx("data/byte.tif", allowed_drivers=["GTiff"])
+    assert ds.ReadRaster() == ds_ref.ReadRaster()
+    assert ds.ReadRaster(1, 2, 1, 1) == ds_ref.ReadRaster(1, 2, 1, 1)
+    assert ds.ReadRaster(band_list=[1, 1]) == ds_ref.ReadRaster(band_list=[1, 1])
+    assert ds.ReadRaster(1, 2, 3, 4) == ds_ref.ReadRaster(1, 2, 3, 4)
+    assert ds.ReadRaster(buf_type=gdal.GDT_Int16) == ds_ref.ReadRaster(
+        buf_type=gdal.GDT_Int16
+    )
+    assert ds.ReadRaster(buf_xsize=3, buf_ysize=5) == ds_ref.ReadRaster(
+        buf_xsize=3, buf_ysize=5
+    )
+    assert ds.ReadRaster(
+        buf_xsize=3, buf_ysize=5, resample_alg=gdal.GRIORA_Bilinear
+    ) == ds_ref.ReadRaster(buf_xsize=3, buf_ysize=5, resample_alg=gdal.GRIORA_Bilinear)
+
+
+@pytest.mark.require_driver("GTiff")
+@pytest.mark.parametrize("GDAL_FORCE_CACHING", ["YES", "NO"])
+def test_libertiff_3band_separate(GDAL_FORCE_CACHING):
+    with gdal.config_option("GDAL_FORCE_CACHING", GDAL_FORCE_CACHING):
+        ds = libertiff_open("data/rgbsmall.tif")
+    ds_ref = gdal.OpenEx("data/rgbsmall.tif", allowed_drivers=["GTiff"])
+    assert ds.ReadRaster() == ds_ref.ReadRaster()
+    assert ds.GetRasterBand(2).ReadRaster() == ds_ref.GetRasterBand(2).ReadRaster()
+    assert ds.ReadRaster(1, 2, 1, 1) == ds_ref.ReadRaster(1, 2, 1, 1)
+    assert ds.ReadRaster(band_list=[3, 2, 1]) == ds_ref.ReadRaster(band_list=[3, 2, 1])
+    assert ds.ReadRaster(1, 2, 3, 4) == ds_ref.ReadRaster(1, 2, 3, 4)
+    assert ds.ReadRaster(buf_type=gdal.GDT_Int16) == ds_ref.ReadRaster(
+        buf_type=gdal.GDT_Int16
+    )
+    assert ds.ReadRaster(buf_xsize=3, buf_ysize=5) == ds_ref.ReadRaster(
+        buf_xsize=3, buf_ysize=5
+    )
+    assert ds.ReadRaster(
+        1.5, 2.5, 6.5, 7.5, buf_xsize=3, buf_ysize=5, resample_alg=gdal.GRIORA_Bilinear
+    ) == ds_ref.ReadRaster(
+        1.5, 2.5, 6.5, 7.5, buf_xsize=3, buf_ysize=5, resample_alg=gdal.GRIORA_Bilinear
+    )
+
+
+@pytest.mark.require_driver("GTiff")
+@pytest.mark.parametrize("GDAL_FORCE_CACHING", ["YES", "NO"])
+def test_libertiff_4band_pixel_interleaved(GDAL_FORCE_CACHING):
+    with gdal.config_option("GDAL_FORCE_CACHING", GDAL_FORCE_CACHING):
+        ds = libertiff_open("data/stefan_full_rgba.tif")
+    ds_ref = gdal.OpenEx("data/stefan_full_rgba.tif", allowed_drivers=["GTiff"])
+    assert ds.ReadRaster() == ds_ref.ReadRaster()
+    assert ds.ReadRaster(buf_pixel_space=4, buf_band_space=1) == ds_ref.ReadRaster(
+        buf_pixel_space=4, buf_band_space=1
+    )
+    assert ds.ReadRaster(band_list=[3, 2, 1, 4]) == ds_ref.ReadRaster(
+        band_list=[3, 2, 1, 4]
+    )
+    assert ds.ReadRaster(band_list=[3, 2, 1]) == ds_ref.ReadRaster(band_list=[3, 2, 1])
+
+
+def test_libertiff_with_ovr():
+    ds = libertiff_open("data/byte_with_ovr.tif")
+    assert ds.GetRasterBand(1).GetOverviewCount() == 2
+    assert ds.GetRasterBand(1).GetOverview(-1) is None
+    assert ds.GetRasterBand(1).GetOverview(2) is None
+    assert ds.GetRasterBand(1).GetOverview(0).Checksum() == 1087
+    assert ds.GetRasterBand(1).GetOverview(1).Checksum() == 328
+    assert (
+        ds.GetRasterBand(1).ReadRaster(buf_xsize=10, buf_ysize=10)
+        == ds.GetRasterBand(1).GetOverview(0).ReadRaster()
+    )
+
+
+@pytest.mark.require_driver("JPEG")
+def test_libertiff_with_mask():
+    ds = libertiff_open("data/ycbcr_with_mask.tif")
+    assert ds.GetSpatialRef() is not None
+    assert ds.RasterCount == 3
+    assert ds.GetRasterBand(1).GetMaskFlags() == gdal.GMF_PER_DATASET
+    assert ds.GetRasterBand(1).GetMaskBand().Checksum() == 1023
+    assert ds.GetRasterBand(1).GetMetadataItem("JPEGTABLES", "TIFF") is not None
+
+
+def test_libertiff_nodata():
+    ds = libertiff_open("data/nan32_nodata.tif")
+    assert math.isnan(ds.GetRasterBand(1).GetNoDataValue())
+
+
+def test_libertiff_sparse_nodata_one():
+    ds = libertiff_open("data/gtiff/sparse_nodata_one.tif")
+    assert ds.GetRasterBand(1).GetNoDataValue() == 1
+    assert ds.GetRasterBand(1).GetMetadataItem("BLOCK_OFFSET_0_0", "TIFF") is None
+    assert ds.GetRasterBand(1).GetMetadataItem("BLOCK_SIZE_0_0", "TIFF") is None
+    assert ds.GetRasterBand(1).Checksum() == 1
+    assert ds.GetRasterBand(1).ReadRaster(0, 0, 1, 1) == b"\x01"
+    assert ds.GetRasterBand(1).ReadRaster(0, 0, 1, 1) == b"\x01"
+
+
+@pytest.mark.parametrize("filename", ["sparse_tiled_separate", "sparse_tiled_contig"])
+def test_libertiff_sparse_tiled(filename):
+    ds = libertiff_open(f"data/gtiff/{filename}.tif")
+    assert ds.GetRasterBand(1).ReadRaster() == b"\x01" * (40 * 21)
+    assert ds.GetRasterBand(1).ReadRaster(0, 0, 1, 1) == b"\x01"
+
+
+def test_libertiff_metadata():
+    ds = libertiff_open("data/complex_float32.tif")
+    assert ds.GetMetadata() == {
+        "bands": "1",
+        "byte_order": "0",
+        "data_type": "6",
+        "description": "File Imported into ENVI.",
+        "file_type": "ENVI Standard",
+        "header_offset": "0",
+        "interleave": "bsq",
+        "lines": "4148",
+        "samples": "9400",
+        "sensor_type": "Unknown",
+        "wavelength_units": "Unknown",
+    }
+
+
+def test_libertiff_check_signed_int8():
+    ds = libertiff_open("../gdrivers/data/gtiff/int8.tif")
+    assert ds.GetRasterBand(1).Checksum() == 1046
+
+
+@pytest.mark.parametrize(
+    "filename", ["int16.tif", "gtiff/int16_big_endian.tif", "int32.tif", "int64.tif"]
+)
+def test_libertiff_check_signed_int(filename):
+    ds = libertiff_open("data/" + filename)
+    assert ds.GetRasterBand(1).Checksum() == 4672
+
+
+@pytest.mark.parametrize(
+    "filename",
+    [
+        "cint16.tif",
+        "cint32.tif",
+        "gtiff/cint32_big_endian.tif",
+        "cfloat32.tif",
+        "cfloat64.tif",
+    ],
+)
+def test_libertiff_check_complex(filename):
+    ds = libertiff_open("data/" + filename)
+    assert ds.GetRasterBand(1).Checksum() == 5028
+
+
+@pytest.mark.parametrize(
+    "filename_middle",
+    [
+        "DEFLATE",
+        "DEFLATE_tiled",
+        "JPEG",
+        "JPEG_tiled",
+        "JXL",
+        "JXL_tiled",
+        "LERC_DEFLATE",
+        "LERC_DEFLATE_tiled",
+        "LERC",
+        "LERC_tiled",
+        "LERC_ZSTD",
+        "LERC_ZSTD_tiled",
+        "little_endian_golden",
+        "little_endian_tiled_lzw_golden",
+        "LZMA",
+        "LZMA_tiled",
+        "LZW_predictor_2",
+        "LZW",
+        "LZW_tiled",
+        "NONE",
+        "NONE_tiled",
+        "ZSTD",
+        "ZSTD_tiled",
+    ],
+)
+def test_libertiff_check_byte(filename_middle):
+    if "JPEG" in filename_middle and gdal.GetDriverByName("JPEG") is None:
+        pytest.skip("JPEG driver missing")
+    if "JXL" in filename_middle and gdal.GetDriverByName("JPEGXL") is None:
+        pytest.skip("JPEGXL driver missing")
+    if "WEBP" in filename_middle and gdal.GetDriverByName("WEBP") is None:
+        pytest.skip("WEBP driver missing")
+    if (
+        "LZMA" in filename_middle
+        and gdal.GetDriverByName("LIBERTIFF").GetMetadataItem(
+            "LZMA_SUPPORT", "LIBERTIFF"
+        )
+        is None
+    ):
+        pytest.skip("LZMA support missing")
+    if (
+        "LERC" in filename_middle
+        and gdal.GetDriverByName("LIBERTIFF").GetMetadataItem(
+            "LERC_SUPPORT", "LIBERTIFF"
+        )
+        is None
+    ):
+        pytest.skip("LERC support missing")
+    if (
+        "ZSTD" in filename_middle
+        and gdal.GetDriverByName("LIBERTIFF").GetMetadataItem(
+            "ZSTD_SUPPORT", "LIBERTIFF"
+        )
+        is None
+    ):
+        pytest.skip("ZSTD support missing")
+
+    ds = libertiff_open(f"data/gtiff/byte_{filename_middle}.tif")
+    if "JPEG" in filename_middle:
+        assert ds.GetRasterBand(1).Checksum() > 0
+        if gdal.GetDriverByName("GTiff"):
+            ds_ref = gdal.OpenEx(
+                f"data/gtiff/byte_{filename_middle}.tif", allowed_drivers=["GTiff"]
+            )
+            assert ds.GetRasterBand(1).Checksum() == ds_ref.GetRasterBand(1).Checksum()
+    else:
+        assert ds.GetRasterBand(1).Checksum() == 4672
+
+
+@pytest.mark.parametrize(
+    "filename_middle",
+    [
+        "byte_LZW_predictor_2",
+        "DEFLATE_separate",
+        "DEFLATE",
+        "DEFLATE_tiled_separate",
+        "DEFLATE_tiled",
+        "JPEG_separate",
+        "JPEG",
+        "JPEG_tiled_separate",
+        "JPEG_tiled",
+        "JPEG_ycbcr",
+        "JXL_separate",
+        "JXL",
+        "JXL_tiled_separate",
+        "JXL_tiled",
+        "LERC_DEFLATE_separate",
+        "LERC_DEFLATE",
+        "LERC_DEFLATE_tiled_separate",
+        "LERC_DEFLATE_tiled",
+        "LERC_separate",
+        "LERC",
+        "LERC_tiled_separate",
+        "LERC_tiled",
+        "LERC_ZSTD_separate",
+        "LERC_ZSTD",
+        "LERC_ZSTD_tiled_separate",
+        "LERC_ZSTD_tiled",
+        "LZMA_separate",
+        "LZMA",
+        "LZMA_tiled_separate",
+        "LZMA_tiled",
+        "LZW_separate",
+        "LZW",
+        "LZW_tiled_separate",
+        "LZW_tiled",
+        "NONE_separate",
+        "NONE",
+        "NONE_tiled_separate",
+        "NONE_tiled",
+        "uint16_LZW_predictor_2",
+        "uint32_LZW_predictor_2",
+        "uint64_LZW_predictor_2",
+        "WEBP",
+        "WEBP_tiled",
+        "ZSTD_separate",
+        "ZSTD",
+        "ZSTD_tiled_separate",
+        "ZSTD_tiled",
+        "int16_bigendian_lzw_predictor_2",
+    ],
+)
+def test_libertiff_check_rgbsmall(filename_middle):
+    if "JPEG" in filename_middle and gdal.GetDriverByName("JPEG") is None:
+        pytest.skip("JPEG driver missing")
+    if "JXL" in filename_middle and gdal.GetDriverByName("JPEGXL") is None:
+        pytest.skip("JPEGXL driver missing")
+    if "WEBP" in filename_middle and gdal.GetDriverByName("WEBP") is None:
+        pytest.skip("WEBP driver missing")
+    if (
+        "LZMA" in filename_middle
+        and gdal.GetDriverByName("LIBERTIFF").GetMetadataItem(
+            "LZMA_SUPPORT", "LIBERTIFF"
+        )
+        is None
+    ):
+        pytest.skip("LZMA support missing")
+    if (
+        "LERC" in filename_middle
+        and gdal.GetDriverByName("LIBERTIFF").GetMetadataItem(
+            "LERC_SUPPORT", "LIBERTIFF"
+        )
+        is None
+    ):
+        pytest.skip("LERC support missing")
+    if (
+        "ZSTD" in filename_middle
+        and gdal.GetDriverByName("LIBERTIFF").GetMetadataItem(
+            "ZSTD_SUPPORT", "LIBERTIFF"
+        )
+        is None
+    ):
+        pytest.skip("ZSTD support missing")
+
+    ds = libertiff_open(f"data/gtiff/rgbsmall_{filename_middle}.tif")
+    if "JPEG" in filename_middle:
+        assert ds.GetRasterBand(1).Checksum() > 0
+        if gdal.GetDriverByName("GTiff"):
+            ds_ref = gdal.OpenEx(
+                f"data/gtiff/rgbsmall_{filename_middle}.tif",
+                allowed_drivers=["GTiff"],
+            )
+            assert [ds.GetRasterBand(i + 1).Checksum() for i in range(3)] == [
+                ds_ref.GetRasterBand(i + 1).Checksum() for i in range(3)
+            ]
+    else:
+        assert [ds.GetRasterBand(i + 1).Checksum() for i in range(3)] == [
+            21212,
+            21053,
+            21349,
+        ]
+    assert ds.GetRasterBand(1).GetMetadataItem("BLOCK_OFFSET_0_0", "TIFF") is not None
+    assert ds.GetRasterBand(1).GetMetadataItem("BLOCK_SIZE_0_0", "TIFF") is not None
+
+
+@pytest.mark.parametrize(
+    "filename_prefix",
+    [
+        "byte_LZW_predictor_2",
+        "float32_LZW_predictor_2",
+        "float32_LZW_predictor_3",
+        "float32_lzw_predictor_3_big_endian",
+        "float64_LZW_predictor_2",
+        "float64_LZW_predictor_3",
+        "uint16_LZW_predictor_2",
+        "uint32_LZW_predictor_2",
+        "uint64_LZW_predictor_2",
+    ],
+)
+def test_libertiff_check_predictor_1_band(filename_prefix):
+    ds = libertiff_open(f"data/gtiff/{filename_prefix}.tif")
+    assert ds.GetRasterBand(1).Checksum() == 4672
+
+
+@pytest.mark.parametrize(
+    "filename_prefix",
+    [
+        "stefan_full_greyalpha_byte_LZW_predictor_2",
+        "stefan_full_greyalpha_uint16_LZW_predictor_2",
+        "stefan_full_greyalpha_uint32_LZW_predictor_2",
+        "stefan_full_greyalpha_uint64_LZW_predictor_2",
+    ],
+)
+def test_libertiff_check_predictor_2_bands(filename_prefix):
+    ds = libertiff_open(f"data/gtiff/{filename_prefix}.tif")
+    assert [ds.GetRasterBand(i + 1).Checksum() for i in range(2)] == [1970, 10807]
+
+
+@pytest.mark.parametrize(
+    "filename_prefix",
+    [
+        "rgbsmall_byte_LZW_predictor_2",
+        "rgbsmall_uint16_LZW_predictor_2",
+        "rgbsmall_uint32_LZW_predictor_2",
+        "rgbsmall_uint64_LZW_predictor_2",
+    ],
+)
+def test_libertiff_check_predictor_3_bands(filename_prefix):
+    ds = libertiff_open(f"data/gtiff/{filename_prefix}.tif")
+    assert [ds.GetRasterBand(i + 1).Checksum() for i in range(3)] == [
+        21212,
+        21053,
+        21349,
+    ]
+
+
+def test_libertiff_read_predictor_4_bands():
+    ds = libertiff_open("data/gtiff/stefan_full_rgba_LZW_predictor_2.tif")
+    assert [ds.GetRasterBand(i + 1).Checksum() for i in range(4)] == [
+        12603,
+        58561,
+        36064,
+        10807,
+    ]
+
+
+def test_libertiff_read_predictor_5_bands():
+    ds = libertiff_open("data/gtiff/byte_5_bands_LZW_predictor_2.tif")
+    assert [ds.GetRasterBand(i + 1).Checksum() for i in range(5)] == [
+        4672,
+        4563,
+        4672,
+        4563,
+        4672,
+    ]
+
+
+###############################################################################
+# Test reading a GeoTIFF file with tiepoints in PixelIsPoint format.
+
+
+def test_libertiff_read_tiepoints_pixelispoint():
+
+    ds = libertiff_open("data/byte_gcp_pixelispoint.tif")
+    assert ds.GetMetadataItem("AREA_OR_POINT") == "Point"
+    assert ds.GetSpatialRef() is None
+    assert ds.GetGCPSpatialRef() is not None
+    assert ds.GetGCPCount() == 4
+    gcp = ds.GetGCPs()[0]
+    assert (
+        gcp.GCPPixel == pytest.approx(0.5, abs=1e-5)
+        and gcp.GCPLine == pytest.approx(0.5, abs=1e-5)
+        and gcp.GCPX == pytest.approx(-180, abs=1e-5)
+        and gcp.GCPY == pytest.approx(90, abs=1e-5)
+        and gcp.GCPZ == pytest.approx(0, abs=1e-5)
+    )
+
+
+###############################################################################
+# Test reading a 4-band contig jpeg compressed geotiff.
+
+
+@pytest.mark.require_driver("JPEG")
+def test_libertiff_rgba_jpeg_contig():
+
+    ds = libertiff_open("data/stefan_full_rgba_jpeg_contig.tif")
+    assert ds.GetRasterBand(1).Checksum() > 0
+    assert ds.GetRasterBand(2).Checksum() > 0
+    assert ds.GetRasterBand(3).Checksum() > 0
+    assert ds.GetRasterBand(4).Checksum() > 0
+
+
+###############################################################################
+# Test reading a 12bit jpeg compressed geotiff.
+
+
+@pytest.mark.skipif(
+    "SKIP_TIFF_JPEG12" in os.environ, reason="Crashes on build-windows-msys2-mingw"
+)
+@pytest.mark.require_driver("JPEG")
+def test_libertiff_12bitjpeg(tmp_vsimem):
+
+    jpeg_drv = gdal.GetDriverByName("JPEG")
+    if "UInt16" not in jpeg_drv.GetMetadataItem(gdal.DMD_CREATIONDATATYPES):
+        pytest.skip("12-bit JPEG not supported in this build")
+
+    filename = str(tmp_vsimem / "tmp.tif")
+    gdal.FileFromMemBuffer(
+        filename, open("data/mandrilmini_12bitjpeg.tif", "rb").read()
+    )
+    ds = libertiff_open(filename)
+
+    stats = ds.GetRasterBand(1).ComputeStatistics(False)
+    assert not (
+        stats[2] < 2150 or stats[2] > 2180 or str(stats[2]) == "nan"
+    ), "did not get expected mean for band1."
+
+
+###############################################################################
+
+
+@pytest.mark.parametrize(
+    "filename", ["data/excessive-memory-TIFFFillStrip.tif", "data/huge4GB.tif"]
+)
+def test_libertiff_read_error(filename):
+
+    ds = libertiff_open(filename)
+    for i in range(ds.RasterCount):
+        with pytest.raises(Exception):
+            ds.GetRasterBand(i + 1).Checksum()
+
+
+###############################################################################
+
+
+@pytest.mark.parametrize(
+    "filename",
+    [
+        "data/huge-number-strips.tiff",
+    ],
+)
+def test_libertiff_open_error(filename):
+
+    with pytest.raises(Exception):
+        libertiff_open(filename)
+
+
+###############################################################################
+# Test we don't crash on files
+
+
+@gdaltest.disable_exceptions()
+def test_libertiff_test_all_tif():
+
+    for filename in glob.glob("data/*.tif"):
+        # print(filename)
+        with gdal.quiet_errors():
+            ds = libertiff_open(filename)
+            if ds and ds.RasterCount:
+                ds.ReadRaster(0, 0, 1, 1)
+
+
+def test_libertiff_thread_safe_readraster():
+
+    ds = libertiff_open("data/gtiff/rgbsmall_DEFLATE_tiled_separate.tif")
+    assert ds.IsThreadSafe(gdal.OF_RASTER)
+
+    res = [True]
+
+    def check():
+        for i in range(100):
+            if [ds.GetRasterBand(i + 1).Checksum() for i in range(3)] != [
+                21212,
+                21053,
+                21349,
+            ]:
+                res[0] = False
+
+    threads = [threading.Thread(target=check) for i in range(2)]
+    for t in threads:
+        t.start()
+    for t in threads:
+        t.join()
+    assert res[0]
+
+
+###############################################################################
+# Test different datatypes for StripOffsets tag with little/big, classic/bigtiff
+
+
+@pytest.mark.parametrize(
+    "filename,expected_offsets",
+    [
+        ("data/classictiff_one_block_byte.tif", [158]),
+        ("data/classictiff_one_block_long.tif", [158]),
+        ("data/classictiff_one_block_be_long.tif", [158]),
+        ("data/classictiff_one_strip_long.tif", [146]),
+        ("data/classictiff_one_strip_be_long.tif", [146]),
+        ("data/classictiff_two_strip_short.tif", [162, 163]),
+        ("data/classictiff_two_strip_be_short.tif", [162, 163]),
+        ("data/classictiff_four_strip_short.tif", [178, 179, 180, 181]),
+        ("data/classictiff_four_strip_be_short.tif", [178, 179, 180, 181]),
+        ("data/bigtiff_four_strip_short.tif", [316, 317, 318, 319]),
+        ("data/bigtiff_four_strip_be_short.tif", [316, 317, 318, 319]),
+        ("data/bigtiff_one_block_long8.tif", [272]),
+        ("data/bigtiff_one_block_be_long8.tif", [272]),
+        ("data/bigtiff_one_strip_long.tif", [252]),
+        ("data/bigtiff_one_strip_be_long.tif", [252]),
+        ("data/bigtiff_one_strip_long8.tif", [252]),
+        ("data/bigtiff_one_strip_be_long8.tif", [252]),
+        ("data/bigtiff_two_strip_long.tif", [284, 285]),
+        ("data/bigtiff_two_strip_be_long.tif", [284, 285]),
+        ("data/bigtiff_two_strip_long8.tif", [284, 285]),
+        ("data/bigtiff_two_strip_be_long8.tif", [284, 285]),
+    ],
+)
+def test_libertiff_read_stripoffset_types(filename, expected_offsets):
+
+    ds = libertiff_open(filename)
+    offsets = []
+    for row in range(4):
+        mdi = ds.GetRasterBand(1).GetMetadataItem("BLOCK_OFFSET_0_%d" % row, "TIFF")
+        if mdi is None:
+            break
+        offsets.append(int(mdi))
+    assert offsets == expected_offsets
+    assert ds.GetRasterBand(1).Checksum() > 0
+
+
+def test_libertiff_packbits():
+    ds = libertiff_open("data/seperate_strip.tif")
+    assert [ds.GetRasterBand(i + 1).Checksum() for i in range(3)] == [
+        15234,
+        15234,
+        15234,
+    ]
+
+
+def test_libertiff_coordinate_epoch():
+    ds = libertiff_open("data/gtiff/byte_coord_epoch.tif")
+    assert ds.GetSpatialRef().GetCoordinateEpoch() == 2020.0
+
+
+@pytest.mark.require_driver("WEBP")
+def test_libertiff_webp_lossy():
+    ds = libertiff_open("data/tif_webp.tif")
+    assert ds.GetMetadata("IMAGE_STRUCTURE") == {
+        "COMPRESSION_REVERSIBILITY": "LOSSY",
+        "COMPRESSION": "WEBP",
+        "INTERLEAVE": "PIXEL",
+    }
+
+
+def test_libertiff_multi_image():
+    ds = libertiff_open("data/twoimages.tif")
+    assert ds.RasterCount == 0
+    assert ds.GetSubDatasets() == [
+        ("GTIFF_DIR:1:data/twoimages.tif", "Page 1 (20P x 20L x 1B)"),
+        ("GTIFF_DIR:2:data/twoimages.tif", "Page 2 (20P x 20L x 1B)"),
+    ]
+
+    with pytest.raises(Exception):
+        libertiff_open("GTIFF_DIR:")
+    with pytest.raises(Exception):
+        libertiff_open("GTIFF_DIR:0")
+    with pytest.raises(Exception):
+        libertiff_open("GTIFF_DIR:-1:data/twoimages.tif")
+    with pytest.raises(Exception):
+        libertiff_open("GTIFF_DIR:0:data/twoimages.tif")
+    with pytest.raises(Exception):
+        libertiff_open("GTIFF_DIR:3:data/twoimages.tif")
+    with pytest.raises(Exception):
+        libertiff_open("GTIFF_DIR:1:i_do_not_exist.tif")
+
+    ds = libertiff_open("GTIFF_DIR:1:data/twoimages.tif")
+    assert ds.GetRasterBand(1).GetMetadataItem("IFD_OFFSET", "TIFF") == "408"
+
+    ds = libertiff_open("GTIFF_DIR:2:data/twoimages.tif")
+    assert ds.GetRasterBand(1).GetMetadataItem("IFD_OFFSET", "TIFF") == "958"
+
+
+def test_libertiff_miniswhite():
+    ds = libertiff_open("data/gtiff/miniswhite.tif")
+    assert ds.GetMetadataItem("MINISWHITE", "IMAGE_STRUCTURE") == "YES"
+    assert ds.GetRasterBand(1).GetColorInterpretation() == gdal.GCI_PaletteIndex
+    ct = ds.GetRasterBand(1).GetColorTable()
+    assert ct
+    assert ct.GetCount() == 2
+    assert ct.GetColorEntry(0) == (255, 255, 255, 255)
+    assert ct.GetColorEntry(1) == (0, 0, 0, 255)
+
+
+def test_libertiff_colortable():
+    ds = libertiff_open("data/test_average_palette.tif")
+    assert ds.GetRasterBand(1).GetColorInterpretation() == gdal.GCI_PaletteIndex
+    ct = ds.GetRasterBand(1).GetColorTable()
+    assert ct
+    assert ct.GetCount() == 256
+    assert ct.GetColorEntry(0) == (0, 0, 0, 255)
+    assert ct.GetColorEntry(1) == (255, 255, 255, 255)
+    assert ct.GetColorEntry(2) == (127, 127, 127, 255)
+
+
+###############################################################################
+# Test reading a TIFF with the RPC tag per
+#  http://geotiff.maptools.org/rpc_prop.html
+
+
+def test_libertiff_read_rpc_tif():
+
+    ds = libertiff_open("data/byte_rpc.tif")
+    got_md = ds.GetMetadata("RPC")
+    expected_md = {
+        "ERR_BIAS": "-1",
+        "ERR_RAND": "-1",
+        "HEIGHT_OFF": "300",
+        "HEIGHT_SCALE": "970",
+        "LAT_OFF": "-42.8607",
+        "LAT_SCALE": "0.0715",
+        "LINE_DEN_COEFF": "1 -0.00520769693945429 0.00549138470185778 "
+        "-0.00472718007439368 -2.02057365543208e-05 "
+        "8.39509604990839e-06 -3.43728317291176e-05 "
+        "-1.94598141718645e-05 2.35660616018416e-05 "
+        "3.71653924834455e-06 7.08406853351595e-08 "
+        "-5.72002373463043e-09 8.71363385561163e-09 "
+        "-4.39082343385483e-09 1.39161295297537e-08 "
+        "-1.24914964124471e-08 4.6171143198849e-08 "
+        "1.70067569381897e-08 -2.37449991316111e-08 "
+        "9.05460084990073e-10",
+        "LINE_NUM_COEFF": "-0.000539636886315094 0.00262771165447159 "
+        "-1.00287836503009 -0.0340303311076584 0.00523658598538616 "
+        "0.00210057328569037 0.00311664695421511 "
+        "0.000406267962891555 -0.00550089873884607 "
+        "5.26202553862825e-05 2.5958707865627e-06 "
+        "-2.23632198653199e-06 2.02822452334703e-05 "
+        "-5.24009408417096e-06 2.16913023637956e-05 "
+        "-2.36002554032361e-05 1.56703932477487e-06 "
+        "-6.14095576183939e-06 1.8422191786661e-05 "
+        "2.01615774485329e-07",
+        "LINE_OFF": "15834",
+        "LINE_SCALE": "15834",
+        "LONG_OFF": "147.2588",
+        "LONG_SCALE": "0.0828",
+        "SAMP_DEN_COEFF": "1 -0.00520769693945429 0.00549138470185778 "
+        "-0.00472718007439368 -2.02057365543208e-05 "
+        "8.39509604990839e-06 -3.43728317291176e-05 "
+        "-1.94598141718645e-05 2.35660616018416e-05 "
+        "3.71653924834455e-06 7.08406853351595e-08 "
+        "-5.72002373463043e-09 8.71363385561163e-09 "
+        "-4.39082343385483e-09 1.39161295297537e-08 "
+        "-1.24914964124471e-08 4.6171143198849e-08 "
+        "1.70067569381897e-08 -2.37449991316111e-08 "
+        "9.05460084990073e-10",
+        "SAMP_NUM_COEFF": "0.00121386429106107 1.0047652205584 0.00363040578479236 "
+        "-0.033702055558379 0.00665808526532754 -0.0036225246184886 "
+        "-0.000251174639124558 -0.00523232964739848 "
+        "1.74629130199178e-05 0.000131049715749837 "
+        "-2.8029900276216e-05 -1.95273546561053e-05 "
+        "2.91977037724833e-05 2.78736117374265e-07 "
+        "-2.64005759423042e-05 7.08277764663844e-08 "
+        "1.12211574945991e-06 1.15330773275834e-06 "
+        "7.15463416011193e-07 -2.42741993962372e-08",
+        "SAMP_OFF": "13464",
+        "SAMP_SCALE": "13464",
+    }
+    assert len(got_md) == len(expected_md)
+    for key in expected_md:
+        expected_value = expected_md[key]
+        got_value = got_md[key]
+        if " " in expected_value:
+            expected_values = expected_value.split(" ")
+            got_values = got_value.split(" ")
+            for i in range(len(expected_values)):
+                assert float(got_values[i]) == pytest.approx(
+                    float(expected_values[i]), rel=1e-10
+                )
+        else:
+            assert float(got_value) == pytest.approx(float(expected_value), rel=1e-10)
+
+
+###############################################################################
+# Corrupt all bytes of an existing file
+
+
+def test_libertiff_corrupted(tmp_vsimem):
+
+    filename = str(tmp_vsimem / "out.tif")
+    data = open("data/gtiff/miniswhite.tif", "rb").read()
+    gdal.FileFromMemBuffer(filename, data)
+    f = gdal.VSIFOpenL(filename, "rb+")
+    try:
+        for i in range(len(data)):
+            gdal.VSIFSeekL(f, i, 0)
+            ori_val = gdal.VSIFReadL(1, 1, f)
+
+            for new_val in (b"\x00", b"\x01", b"\x7F", b"\xFE", b"\xFF"):
+                gdal.VSIFSeekL(f, i, 0)
+                gdal.VSIFWriteL(new_val, 1, 1, f)
+                try:
+                    ds = libertiff_open(filename)
+                    ds.ReadRaster()
+                except Exception:
+                    pass
+
+            # Restore old value
+            gdal.VSIFSeekL(f, i, 0)
+            gdal.VSIFWriteL(ori_val, 1, 1, f)
+    finally:
+        gdal.VSIFCloseL(f)
+
+
+def test_libertiff_srs_read_epsg4326_3855_geotiff1_1():
+    ds = libertiff_open("data/epsg4326_3855_geotiff1_1.tif")
+    sr = ds.GetSpatialRef()
+    assert sr.GetName() == "WGS 84 + EGM2008 height"
+    assert sr.GetAuthorityCode("COMPD_CS|GEOGCS") == "4326"
+    assert sr.GetAuthorityCode("COMPD_CS|VERT_CS") == "3855"
+
+
+def test_libertiff_srs_read_epsg4979_geotiff1_1():
+    ds = libertiff_open("data/epsg4979_geotiff1_1.tif")
+    sr = ds.GetSpatialRef()
+    assert sr.GetAuthorityCode(None) == "4979"
+
+
+def test_libertiff_strip_block_size():
+    ds = libertiff_open("data/utmsmall.tif")
+    assert ds.GetRasterBand(1).GetBlockSize() == [100, 81]
+
+
+def test_libertiff_non_square_pixels():
+    ds = libertiff_open("data/gtiff/non_square_pixels.tif")
+    assert ds.GetGeoTransform() == (2.0, 1.0, 0, 50.0, 0, -0.5)
+
+
+###############################################################################
+# Test reading a GeoTIFF file with a geomatrix (ie non zero rotation terms)
+
+
+def test_libertiff_read_geomatrix():
+
+    ds = libertiff_open("data/geomatrix.tif")
+    assert ds.GetGeoTransform() == (1841001.75, 1.5, -5.0, 1144003.25, -5.0, -1.5)
diff --git a/autotest/pymod/gdaltest.py b/autotest/pymod/gdaltest.py
index 77da5d307872..a17d6bce3ada 100755
--- a/autotest/pymod/gdaltest.py
+++ b/autotest/pymod/gdaltest.py
@@ -218,6 +218,14 @@ def testOpen(
                             drv_name.lower() == "biggif"
                             and self.drivername.lower() == "gif"
                         )
+                        or (
+                            drv_name.lower() == "gtiff"
+                            and self.drivername.lower() == "libertiff"
+                        )
+                        or (
+                            drv_name.lower() == "libertiff"
+                            and self.drivername.lower() == "gtiff"
+                        )
                     ):
                         drivers += [drv_name]
                 other_ds = None
diff --git a/doc/source/drivers/raster/gtiff.rst b/doc/source/drivers/raster/gtiff.rst
index f6d4f722c42a..5f685fec05e6 100644
--- a/doc/source/drivers/raster/gtiff.rst
+++ b/doc/source/drivers/raster/gtiff.rst
@@ -25,6 +25,9 @@ file, such as YCbCr color model files, are automatically translated into
 RGBA (red, green, blue, alpha) form, and treated as four eight bit
 bands.
 
+For an alternative which offers thread-safe read-only capabilities, consult
+:ref:`raster.libertiff`.
+
 Driver capabilities
 -------------------
 
diff --git a/doc/source/drivers/raster/index.rst b/doc/source/drivers/raster/index.rst
index 0e511f99951f..7231e3208a3e 100644
--- a/doc/source/drivers/raster/index.rst
+++ b/doc/source/drivers/raster/index.rst
@@ -109,6 +109,7 @@ Raster drivers
    l1b
    lcp
    leveller
+   libertiff
    loslas
    map
    marfa
diff --git a/doc/source/drivers/raster/libertiff.rst b/doc/source/drivers/raster/libertiff.rst
new file mode 100644
index 000000000000..89d6b9b472d9
--- /dev/null
+++ b/doc/source/drivers/raster/libertiff.rst
@@ -0,0 +1,36 @@
+.. _raster.libertiff:
+
+================================================================================
+LIBERTIFF -- GeoTIFF File Format
+================================================================================
+
+.. versionadded:: 3.11
+
+.. shortname:: LIBERTIFF
+
+.. built_in_by_default::
+
+This driver is a natively thread-safe alternative to the default
+:ref:`raster.gtiff` driver. Note that the driver is read-only.
+
+The driver is registered after the GTiff one. Consequently one must explicitly
+specify ``LIBERTIFF`` in the allowed drivers of the :cpp:func:`GDALOpenEx`, or
+with the ``-if`` option of command line utilities, to use it.
+
+The driver supports the following compression methods: LZW, Deflate, PackBits,
+LZMA, ZSTD, LERC, JPEG, WEBP and JPEGXL.
+The driver supports only BitsPerSample values of 1, 8, 16, 32, 64.
+
+The driver does *not* read any side-car file: ``.aux.xml``, ``.ovr``, ``.msk``,
+``.imd``, etc.
+
+The driver mostly by-passes the GDAL raster block cache, and only caches (per-thread)
+the last tile or strip it has read. Read patterns must be adapted accordingly,
+to avoid repeated data acquisition from storage and decompression.
+
+Driver capabilities
+-------------------
+
+.. supports_georeferencing::
+
+.. supports_virtualio::
diff --git a/frmts/CMakeLists.txt b/frmts/CMakeLists.txt
index 23a5a3a78607..a484587b6d55 100644
--- a/frmts/CMakeLists.txt
+++ b/frmts/CMakeLists.txt
@@ -79,6 +79,7 @@ if (CMAKE_BUILD_TYPE MATCHES "Debug" OR GDAL_ENABLE_DRIVER_NULL)
   gdal_optional_format(null "NULL dummy driver")
 endif ()
 
+gdal_optional_format(libertiff "GeoTIFF support through libertiff library")
 gdal_optional_format(hfa "Erdas Imagine .img")
 gdal_optional_format(sdts "SDTS translator")
 gdal_optional_format(nitf "National Imagery Transmission Format")
diff --git a/frmts/drivers.ini b/frmts/drivers.ini
index 11d381945755..c28e48407382 100644
--- a/frmts/drivers.ini
+++ b/frmts/drivers.ini
@@ -17,6 +17,7 @@ GTI
 SNAP_TIFF
 GTiff
 COG
+LIBERTIFF
 NITF
 RPFTOC
 ECRGTOC
diff --git a/frmts/gdalallregister.cpp b/frmts/gdalallregister.cpp
index 005fd734ce89..a8f073396e17 100644
--- a/frmts/gdalallregister.cpp
+++ b/frmts/gdalallregister.cpp
@@ -332,6 +332,10 @@ void CPL_STDCALL GDALAllRegister()
     GDALRegister_COG();
 #endif
 
+#ifdef FRMT_libertiff
+    GDALRegister_LIBERTIFF();
+#endif
+
 #ifdef FRMT_nitf
     GDALRegister_NITF();
     GDALRegister_RPFTOC();
diff --git a/frmts/gtiff/libtiff/tif_lerc.c b/frmts/gtiff/libtiff/tif_lerc.c
index d57b1d253de5..de824c7092b8 100644
--- a/frmts/gtiff/libtiff/tif_lerc.c
+++ b/frmts/gtiff/libtiff/tif_lerc.c
@@ -93,7 +93,6 @@ typedef struct
 #define LERCDecoderState(tif) GetLERCState(tif)
 #define LERCEncoderState(tif) GetLERCState(tif)
 
-static int LERCEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s);
 static int LERCDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s);
 
 static int LERCFixupTags(TIFF *tif)
@@ -222,7 +221,7 @@ static int SetupBuffers(TIFF *tif, LERCState *sp, const char *module)
     {
         TIFFErrorExtR(tif, module, "Too large uncompressed strip/tile");
         _TIFFfreeExt(tif, sp->uncompressed_buffer);
-        sp->uncompressed_buffer = 0;
+        sp->uncompressed_buffer = NULL;
         sp->uncompressed_alloc = 0;
         return 0;
     }
@@ -230,12 +229,12 @@ static int SetupBuffers(TIFF *tif, LERCState *sp, const char *module)
     if (sp->uncompressed_alloc < new_alloc)
     {
         _TIFFfreeExt(tif, sp->uncompressed_buffer);
-        sp->uncompressed_buffer = _TIFFmallocExt(tif, new_alloc);
+        sp->uncompressed_buffer = (uint8_t *)_TIFFmallocExt(tif, new_alloc);
         if (!sp->uncompressed_buffer)
         {
             TIFFErrorExtR(tif, module, "Cannot allocate buffer");
             _TIFFfreeExt(tif, sp->uncompressed_buffer);
-            sp->uncompressed_buffer = 0;
+            sp->uncompressed_buffer = NULL;
             sp->uncompressed_alloc = 0;
             return 0;
         }
@@ -267,7 +266,7 @@ static int SetupBuffers(TIFF *tif, LERCState *sp, const char *module)
                 TIFFErrorExtR(tif, module, "Cannot allocate buffer");
                 sp->mask_size = 0;
                 _TIFFfreeExt(tif, sp->uncompressed_buffer);
-                sp->uncompressed_buffer = 0;
+                sp->uncompressed_buffer = NULL;
                 sp->uncompressed_alloc = 0;
                 return 0;
             }
@@ -348,7 +347,7 @@ static int LERCPreDecode(TIFF *tif, uint16_t s)
             return 0;
         }
         assert(lerc_data_sizet == (unsigned int)lerc_data_sizet);
-        lerc_data = sp->compressed_buffer;
+        lerc_data = (uint8_t *)sp->compressed_buffer;
         lerc_data_size = (unsigned int)lerc_data_sizet;
 #else
         z_stream strm;
@@ -369,7 +368,7 @@ static int LERCPreDecode(TIFF *tif, uint16_t s)
         strm.avail_in = (uInt)tif->tif_rawcc;
         strm.next_in = tif->tif_rawcp;
         strm.avail_out = sp->compressed_size;
-        strm.next_out = sp->compressed_buffer;
+        strm.next_out = (Bytef *)sp->compressed_buffer;
         zlib_ret = inflate(&strm, Z_FINISH);
         if (zlib_ret != Z_STREAM_END && zlib_ret != Z_OK)
         {
@@ -377,7 +376,7 @@ static int LERCPreDecode(TIFF *tif, uint16_t s)
             inflateEnd(&strm);
             return 0;
         }
-        lerc_data = sp->compressed_buffer;
+        lerc_data = (uint8_t *)sp->compressed_buffer;
         lerc_data_size = sp->compressed_size - strm.avail_out;
         inflateEnd(&strm);
 #endif
@@ -396,7 +395,7 @@ static int LERCPreDecode(TIFF *tif, uint16_t s)
             return 0;
         }
 
-        lerc_data = sp->compressed_buffer;
+        lerc_data = (uint8_t *)sp->compressed_buffer;
         lerc_data_size = (unsigned int)zstd_ret;
 #else
         TIFFErrorExtR(tif, module, "ZSTD support missing");
@@ -568,7 +567,7 @@ static int LERCPreDecode(TIFF *tif, uint16_t s)
         {
             _TIFFfreeExt(tif, sp->uncompressed_buffer_multiband);
             sp->uncompressed_buffer_multiband =
-                _TIFFmallocExt(tif, num_bytes_needed);
+                (uint8_t *)_TIFFmallocExt(tif, num_bytes_needed);
             if (!sp->uncompressed_buffer_multiband)
             {
                 sp->uncompressed_buffer_multiband_alloc = 0;
@@ -752,7 +751,7 @@ static int LERCDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
     assert(sp != NULL);
     assert(sp->state == LSTATE_INIT_DECODE);
 
-    if (sp->uncompressed_buffer == 0)
+    if (sp->uncompressed_buffer == NULL)
     {
         memset(op, 0, (size_t)occ);
         TIFFErrorExtR(tif, module, "Uncompressed buffer not allocated");
@@ -773,6 +772,8 @@ static int LERCDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
     return 1;
 }
 
+#ifndef LERC_READ_ONLY
+
 static int LERCSetupEncode(TIFF *tif)
 {
     LERCState *sp = LERCEncoderState(tif);
@@ -1005,7 +1006,7 @@ static int LERCPostEncode(TIFF *tif)
                 {
                     _TIFFfreeExt(tif, sp->uncompressed_buffer_multiband);
                     sp->uncompressed_buffer_multiband =
-                        _TIFFmallocExt(tif, num_bytes_needed);
+                        (uint8_t *)_TIFFmallocExt(tif, num_bytes_needed);
                     if (!sp->uncompressed_buffer_multiband)
                     {
                         sp->uncompressed_buffer_multiband_alloc = 0;
@@ -1126,7 +1127,8 @@ static int LERCPostEncode(TIFF *tif)
             sp->uncompressed_buffer_multiband, sp->lerc_version,
             GetLercDataType(tif), 1, sp->segment_width, sp->segment_height,
             dst_nbands, dst_nbands, sp->mask_buffer, sp->maxzerror,
-            sp->compressed_buffer, sp->compressed_size, &numBytesWritten);
+            (unsigned char *)sp->compressed_buffer, sp->compressed_size,
+            &numBytesWritten);
     }
     else
 #endif
@@ -1139,7 +1141,8 @@ static int LERCPostEncode(TIFF *tif)
             use_mask ? 1 : 0,
 #endif
             use_mask ? sp->mask_buffer : NULL, sp->maxzerror,
-            sp->compressed_buffer, sp->compressed_size, &numBytesWritten);
+            (unsigned char *)sp->compressed_buffer, sp->compressed_size,
+            &numBytesWritten);
     }
     if (lerc_ret != 0)
     {
@@ -1271,7 +1274,7 @@ static int LERCPostEncode(TIFF *tif)
     {
         int ret;
         uint8_t *tif_rawdata_backup = tif->tif_rawdata;
-        tif->tif_rawdata = sp->compressed_buffer;
+        tif->tif_rawdata = (uint8_t *)sp->compressed_buffer;
         tif->tif_rawcc = numBytesWritten;
         ret = TIFFFlushData1(tif);
         tif->tif_rawdata = tif_rawdata_backup;
@@ -1282,11 +1285,13 @@ static int LERCPostEncode(TIFF *tif)
     return 1;
 }
 
+#endif /* LERC_READ_ONLY */
+
 static void LERCCleanup(TIFF *tif)
 {
     LERCState *sp = GetLERCState(tif);
 
-    assert(sp != 0);
+    assert(sp != NULL);
 
     tif->tif_tagmethods.vgetfield = sp->vgetparent;
     tif->tif_tagmethods.vsetfield = sp->vsetparent;
@@ -1312,20 +1317,21 @@ static void LERCCleanup(TIFF *tif)
 static const TIFFField LERCFields[] = {
     {TIFFTAG_LERC_PARAMETERS, TIFF_VARIABLE2, TIFF_VARIABLE2, TIFF_LONG, 0,
      TIFF_SETGET_C32_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, FALSE, TRUE,
-     "LercParameters", NULL},
+     (char *)"LercParameters", NULL},
     {TIFFTAG_LERC_MAXZERROR, 0, 0, TIFF_ANY, 0, TIFF_SETGET_DOUBLE,
-     TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "LercMaximumError",
-     NULL},
+     TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE,
+     (char *)"LercMaximumError", NULL},
     {TIFFTAG_LERC_VERSION, 0, 0, TIFF_ANY, 0, TIFF_SETGET_UINT32,
-     TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "LercVersion", NULL},
+     TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, (char *)"LercVersion",
+     NULL},
     {TIFFTAG_LERC_ADD_COMPRESSION, 0, 0, TIFF_ANY, 0, TIFF_SETGET_UINT32,
      TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE,
-     "LercAdditionalCompression", NULL},
+     (char *)"LercAdditionalCompression", NULL},
     {TIFFTAG_ZSTD_LEVEL, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT,
      TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE,
-     "ZSTD zstd_compress_level", NULL},
+     (char *)"ZSTD zstd_compress_level", NULL},
     {TIFFTAG_ZIPQUALITY, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT,
-     TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "", NULL},
+     TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, (char *)"", NULL},
 };
 
 static int LERCVSetFieldBase(TIFF *tif, uint32_t tag, ...)
@@ -1517,12 +1523,14 @@ int TIFFInitLERC(TIFF *tif, int scheme)
     tif->tif_decoderow = LERCDecode;
     tif->tif_decodestrip = LERCDecode;
     tif->tif_decodetile = LERCDecode;
+#ifndef LERC_READ_ONLY
     tif->tif_setupencode = LERCSetupEncode;
     tif->tif_preencode = LERCPreEncode;
     tif->tif_postencode = LERCPostEncode;
     tif->tif_encoderow = LERCEncode;
     tif->tif_encodestrip = LERCEncode;
     tif->tif_encodetile = LERCEncode;
+#endif
     tif->tif_cleanup = LERCCleanup;
 
     /* Default values for codec-specific fields */
diff --git a/frmts/gtiff/libtiff/tif_lzw.c b/frmts/gtiff/libtiff/tif_lzw.c
index 4baf78e50b20..c15c7eebc9e4 100644
--- a/frmts/gtiff/libtiff/tif_lzw.c
+++ b/frmts/gtiff/libtiff/tif_lzw.c
@@ -168,7 +168,6 @@ static int LZWDecode(TIFF *tif, uint8_t *op0, tmsize_t occ0, uint16_t s);
 #ifdef LZW_COMPAT
 static int LZWDecodeCompat(TIFF *tif, uint8_t *op0, tmsize_t occ0, uint16_t s);
 #endif
-static void cl_hash(LZWCodecState *);
 
 /*
  * LZW Decoder.
@@ -1017,6 +1016,10 @@ static int LZWDecodeCompat(TIFF *tif, uint8_t *op0, tmsize_t occ0, uint16_t s)
 }
 #endif /* LZW_COMPAT */
 
+#ifndef LZW_READ_ONLY
+
+static void cl_hash(LZWCodecState *);
+
 /*
  * LZW Encoding.
  */
@@ -1373,11 +1376,13 @@ static void cl_hash(LZWCodecState *sp)
         hp->hash = -1;
 }
 
+#endif
+
 static void LZWCleanup(TIFF *tif)
 {
     (void)TIFFPredictorCleanup(tif);
 
-    assert(tif->tif_data != 0);
+    assert(tif->tif_data != NULL);
 
     if (LZWDecoderState(tif)->dec_codetab)
         _TIFFfreeExt(tif, LZWDecoderState(tif)->dec_codetab);
@@ -1416,12 +1421,14 @@ int TIFFInitLZW(TIFF *tif, int scheme)
     tif->tif_decoderow = LZWDecode;
     tif->tif_decodestrip = LZWDecode;
     tif->tif_decodetile = LZWDecode;
+#ifndef LZW_READ_ONLY
     tif->tif_setupencode = LZWSetupEncode;
     tif->tif_preencode = LZWPreEncode;
     tif->tif_postencode = LZWPostEncode;
     tif->tif_encoderow = LZWEncode;
     tif->tif_encodestrip = LZWEncode;
     tif->tif_encodetile = LZWEncode;
+#endif
     tif->tif_cleanup = LZWCleanup;
     /*
      * Setup predictor setup.
diff --git a/frmts/gtiff/libtiff/tif_packbits.c b/frmts/gtiff/libtiff/tif_packbits.c
index 1ae50cbd47ce..d7db9b64ea36 100644
--- a/frmts/gtiff/libtiff/tif_packbits.c
+++ b/frmts/gtiff/libtiff/tif_packbits.c
@@ -31,6 +31,8 @@
  */
 #include <stdio.h>
 
+#ifndef PACKBITS_READ_ONLY
+
 static int PackBitsPreEncode(TIFF *tif, uint16_t s)
 {
     (void)s;
@@ -78,7 +80,7 @@ static int PackBitsEncode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
     op = tif->tif_rawcp;
     ep = tif->tif_rawdata + tif->tif_rawdatasize;
     state = BASE;
-    lastliteral = 0;
+    lastliteral = NULL;
     while (cc > 0)
     {
         /*
@@ -231,6 +233,8 @@ static int PackBitsEncodeChunk(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
     return (1);
 }
 
+#endif
+
 static int PackBitsDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
 {
     static const char module[] = "PackBitsDecode";
@@ -314,11 +318,13 @@ int TIFFInitPackBits(TIFF *tif, int scheme)
     tif->tif_decoderow = PackBitsDecode;
     tif->tif_decodestrip = PackBitsDecode;
     tif->tif_decodetile = PackBitsDecode;
+#ifndef PACKBITS_READ_ONLY
     tif->tif_preencode = PackBitsPreEncode;
     tif->tif_postencode = PackBitsPostEncode;
     tif->tif_encoderow = PackBitsEncode;
     tif->tif_encodestrip = PackBitsEncodeChunk;
     tif->tif_encodetile = PackBitsEncodeChunk;
+#endif
     return (1);
 }
 #endif /* PACKBITS_SUPPORT */
diff --git a/frmts/libertiff/CMakeLists.txt b/frmts/libertiff/CMakeLists.txt
new file mode 100644
index 000000000000..0d24507c4ee8
--- /dev/null
+++ b/frmts/libertiff/CMakeLists.txt
@@ -0,0 +1,46 @@
+add_gdal_driver(
+  TARGET gdal_LIBERTIFF
+  SOURCES libertiffdataset.cpp
+  STRONG_CXX_WFLAGS
+  PLUGIN_CAPABLE_IF
+          "NOT GDAL_USE_LERC_INTERNAL\\\;NOT GDAL_USE_ZLIB_INTERNAL"
+  NO_DEPS)
+
+gdal_standard_includes(gdal_LIBERTIFF)
+target_include_directories(gdal_LIBERTIFF PRIVATE
+    ${GDAL_RASTER_FORMAT_SOURCE_DIR}/mem
+    ${GDAL_RASTER_FORMAT_SOURCE_DIR}/gtiff/libtiff
+    ${PROJECT_SOURCE_DIR}/third_party/libertiff
+)
+
+# Include first internal libraries
+if (GDAL_USE_ZLIB_INTERNAL)
+  gdal_add_vendored_lib(gdal_LIBERTIFF libz)
+endif ()
+
+if (GDAL_USE_LERC_INTERNAL)
+  target_compile_definitions(gdal_LIBERTIFF PRIVATE -DLERC_SUPPORT)
+  gdal_add_vendored_lib(gdal_LIBERTIFF lerc)
+endif ()
+
+# Now external libraries
+
+if (NOT GDAL_USE_ZLIB_INTERNAL)
+  gdal_target_link_libraries(gdal_LIBERTIFF PRIVATE ZLIB::ZLIB)
+endif ()
+
+if (GDAL_USE_DEFLATE)
+  target_compile_definitions(gdal_LIBERTIFF PRIVATE -DLIBDEFLATE_SUPPORT)
+  gdal_target_link_libraries(gdal_LIBERTIFF PRIVATE Deflate::Deflate)
+endif ()
+
+if (NOT GDAL_USE_LERC_INTERNAL AND GDAL_USE_LERC)
+  target_compile_definitions(gdal_LIBERTIFF PRIVATE -DLERC_SUPPORT)
+  gdal_target_link_libraries(gdal_LIBERTIFF PRIVATE LERC::LERC)
+endif ()
+
+if (GDAL_USE_ZSTD)
+  target_compile_definitions(gdal_LIBERTIFF PRIVATE -DZSTD_SUPPORT)
+  gdal_target_link_libraries(gdal_LIBERTIFF PRIVATE ${ZSTD_TARGET})
+endif ()
+
diff --git a/frmts/libertiff/libertiffdataset.cpp b/frmts/libertiff/libertiffdataset.cpp
new file mode 100644
index 000000000000..bf8cbbf19603
--- /dev/null
+++ b/frmts/libertiff/libertiffdataset.cpp
@@ -0,0 +1,3379 @@
+/******************************************************************************
+ *
+ * Project:  GDAL Core
+ * Purpose:  GeoTIFF thread safe reader using libertiff library.
+ * Author:   Even Rouault <even dot rouault at spatialys.com>
+ *
+ ******************************************************************************
+ * Copyright (c) 2024, Even Rouault <even dot rouault at spatialys.com>
+ *
+ * SPDX-License-Identifier: MIT
+ ****************************************************************************/
+
+#include "cpl_compressor.h"
+#include "cpl_mem_cache.h"
+#include "cpl_minixml.h"
+#include "cpl_vsi_virtual.h"
+
+#include <algorithm>
+#include <array>
+#include <limits>
+#include <map>
+#include <mutex>
+#include <type_traits>
+
+#include "gdal_pam.h"
+#include "gdal_mdreader.h"
+#include "gdal_interpolateatpoint.h"
+#include "memdataset.h"
+
+#define LIBERTIFF_NS GDALLibertiffDataset
+#include "libertiff.hpp"
+
+#include "libtiff_codecs.h"
+
+#define STRINGIFY(x) #x
+#define XSTRINGIFY(x) STRINGIFY(x)
+
+/************************************************************************/
+/*                       LIBERTIFFDatasetFileReader                     */
+/************************************************************************/
+
+struct LIBERTIFFDatasetFileReader final : public LIBERTIFF_NS::FileReader
+{
+    VSILFILE *const m_fp;
+    const bool m_bHasPread;
+    mutable bool m_bPReadAllowed = false;
+    mutable uint64_t m_nFileSize = 0;
+    mutable std::mutex m_oMutex{};
+
+    explicit LIBERTIFFDatasetFileReader(VSILFILE *fp)
+        : m_fp(fp), m_bHasPread(m_fp->HasPRead())
+    {
+    }
+
+    uint64_t size() const override
+    {
+        if (m_nFileSize == 0)
+        {
+            std::lock_guard oLock(m_oMutex);
+            // cppcheck-suppress identicalInnerCondition
+            if (m_nFileSize == 0)
+            {
+                m_fp->Seek(0, SEEK_END);
+                m_nFileSize = m_fp->Tell();
+            }
+        }
+        return m_nFileSize;
+    }
+
+    size_t read(uint64_t offset, size_t count, void *buffer) const override
+    {
+        if (m_bHasPread && m_bPReadAllowed)
+        {
+            return m_fp->PRead(buffer, count, offset);
+        }
+        else
+        {
+            std::lock_guard oLock(m_oMutex);
+            return m_fp->Seek(offset, SEEK_SET) == 0
+                       ? m_fp->Read(buffer, 1, count)
+                       : 0;
+        }
+    }
+
+    void setPReadAllowed() const
+    {
+        m_bPReadAllowed = true;
+    }
+
+    CPL_DISALLOW_COPY_ASSIGN(LIBERTIFFDatasetFileReader)
+};
+
+/************************************************************************/
+/*                         LIBERTIFFDataset                             */
+/************************************************************************/
+
+class LIBERTIFFDataset final : public GDALPamDataset
+{
+  public:
+    LIBERTIFFDataset() = default;
+
+    static int Identify(GDALOpenInfo *poOpenInfo);
+    static GDALDataset *OpenStatic(GDALOpenInfo *poOpenInfo);
+
+    const OGRSpatialReference *GetSpatialRef() const override
+    {
+        return m_aoGCPs.empty() && !m_oSRS.IsEmpty() ? &m_oSRS : nullptr;
+    }
+
+    CPLErr GetGeoTransform(double *padfGeoTransform) override
+    {
+        memcpy(padfGeoTransform, m_geotransform.data(),
+               m_geotransform.size() * sizeof(double));
+        return m_geotransformValid ? CE_None : CE_Failure;
+    }
+
+    int GetGCPCount() override
+    {
+        return static_cast<int>(m_aoGCPs.size());
+    }
+
+    const OGRSpatialReference *GetGCPSpatialRef() const override
+    {
+        return !m_aoGCPs.empty() && !m_oSRS.IsEmpty() ? &m_oSRS : nullptr;
+    }
+
+    const GDAL_GCP *GetGCPs() override
+    {
+        return gdal::GCP::c_ptr(m_aoGCPs);
+    }
+
+  protected:
+    CPLErr IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize,
+                     int nYSize, void *pData, int nBufXSize, int nBufYSize,
+                     GDALDataType eBufType, int nBandCount,
+                     BANDMAP_TYPE panBandMap, GSpacing nPixelSpace,
+                     GSpacing nLineSpace, GSpacing nBandSpace,
+                     GDALRasterIOExtraArg *psExtraArg) override;
+
+    CPLErr BlockBasedRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
+                              int nXSize, int nYSize, void *pData,
+                              int nBufXSize, int nBufYSize,
+                              GDALDataType eBufType, int nBandCount,
+                              const int *panBandMap, GSpacing nPixelSpace,
+                              GSpacing nLineSpace, GSpacing nBandSpace,
+                              GDALRasterIOExtraArg *psExtraArg) override
+    {
+        return IRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize, pData,
+                         nBufXSize, nBufYSize, eBufType, nBandCount,
+                         const_cast<BANDMAP_TYPE>(panBandMap), nPixelSpace,
+                         nLineSpace, nBandSpace, psExtraArg);
+    }
+
+  private:
+    friend class LIBERTIFFBand;
+    VSIVirtualHandleUniquePtr m_poFile{};
+    std::shared_ptr<const LIBERTIFFDatasetFileReader> m_fileReader{};
+    std::unique_ptr<const LIBERTIFF_NS::Image> m_image{};
+    const CPLCompressor *m_decompressor = nullptr;
+    std::shared_ptr<int> m_validityPtr = std::make_shared<int>(0);
+    OGRSpatialReference m_oSRS{};
+    bool m_geotransformValid = false;
+    std::array<double, 6> m_geotransform{1, 0, 0, 0, 0, 1};
+    std::vector<gdal::GCP> m_aoGCPs{};
+    std::vector<std::unique_ptr<LIBERTIFFDataset>> m_apoOvrDSOwned{};
+    std::vector<LIBERTIFFDataset *> m_apoOvrDS{};
+    GDALRasterBand *m_poAlphaBand = nullptr;
+    std::unique_ptr<LIBERTIFFDataset> m_poMaskDS{};
+    bool m_bExpand1To255 = false;
+    std::vector<uint8_t> m_jpegTablesOri{};
+    std::vector<uint8_t> m_jpegTables{};
+    std::vector<uint32_t> m_tileOffsets{};
+    std::vector<uint64_t> m_tileOffsets64{};
+    std::vector<uint32_t> m_tileByteCounts{};
+    int m_lercVersion = LERC_VERSION_2_4;
+    int m_lercAdditionalCompression = LERC_ADD_COMPRESSION_NONE;
+    std::vector<uint16_t> m_extraSamples{};
+
+    struct ThreadLocalState
+    {
+      private:
+        std::weak_ptr<int> m_validityTest{};
+
+      public:
+        explicit ThreadLocalState(const LIBERTIFFDataset *ds)
+            : m_validityTest(ds->m_validityPtr)
+        {
+            memset(&m_tiff, 0, sizeof(m_tiff));
+        }
+
+        ~ThreadLocalState()
+        {
+            if (m_tiff.tif_cleanup)
+                m_tiff.tif_cleanup(&m_tiff);
+        }
+
+        inline bool isValid() const
+        {
+            return m_validityTest.lock() != nullptr;
+        }
+
+        // Used by IRasterIO()
+        std::vector<GByte> m_abyIRasterIOBuffer{};
+
+        // Used by ReadBlock()
+        uint64_t m_curStrileIdx = std::numeric_limits<uint64_t>::max();
+        bool m_curStrileMissing = false;
+        std::vector<GByte> m_decompressedBuffer{};
+        std::vector<GByte> m_compressedBuffer{};
+        std::vector<GByte> m_bufferForOneBitExpansion{};
+        std::vector<void *> m_apabyDest{};
+        std::vector<uint8_t> m_floatingPointHorizPredictorDecodeTmpBuffer{};
+
+        TIFF m_tiff{};
+    };
+
+    GDALDataType ComputeGDALDataType() const;
+    bool ProcessCompressionMethod();
+
+    bool Open(std::unique_ptr<const LIBERTIFF_NS::Image> image);
+
+    bool Open(GDALOpenInfo *poOpenInfo);
+
+    ThreadLocalState &GetTLSState() const;
+
+    void ReadSRS();
+    void ReadGeoTransform();
+    void ReadRPCTag();
+
+    bool ReadBlock(GByte *pabyBlockData, int nBlockXOff, int nBlockYOff,
+                   int nBandCount, BANDMAP_TYPE panBandMap,
+                   GDALDataType eBufType, GSpacing nPixelSpace,
+                   GSpacing nLineSpace, GSpacing nBandSpace) const;
+
+    CPL_DISALLOW_COPY_ASSIGN(LIBERTIFFDataset)
+};
+
+/************************************************************************/
+/*                          LIBERTIFFBand                               */
+/************************************************************************/
+
+class LIBERTIFFBand final : public GDALPamRasterBand
+{
+  public:
+    LIBERTIFFBand(LIBERTIFFDataset *poDSIn, int nBandIn, GDALDataType eDT,
+                  int nBlockXSizeIn, int nBlockYSizeIn)
+    {
+        poDS = poDSIn;
+        nBand = nBandIn;
+        eDataType = eDT;
+        nBlockXSize = nBlockXSizeIn;
+        nBlockYSize = nBlockYSizeIn;
+    }
+
+    double GetNoDataValue(int *pbHasNoData) override
+    {
+        if (pbHasNoData)
+            *pbHasNoData = m_bHasNoData;
+        return m_dfNoData;
+    }
+
+    double GetScale(int *pbHasNoData) override
+    {
+        if (pbHasNoData)
+            *pbHasNoData = m_bHaveOffsetScale;
+        return m_dfScale;
+    }
+
+    double GetOffset(int *pbHasNoData) override
+    {
+        if (pbHasNoData)
+            *pbHasNoData = m_bHaveOffsetScale;
+        return m_dfOffset;
+    }
+
+    const char *GetDescription() const override
+    {
+        return m_osDescription.c_str();
+    }
+
+    const char *GetUnitType() override
+    {
+        return m_osUnitType.c_str();
+    }
+
+    GDALColorInterp GetColorInterpretation() override
+    {
+        return m_eColorInterp;
+    }
+
+    GDALColorTable *GetColorTable() override
+    {
+        return m_poColorTable.get();
+    }
+
+    int GetOverviewCount() override
+    {
+        auto l_poDS = cpl::down_cast<LIBERTIFFDataset *>(poDS);
+        return static_cast<int>(l_poDS->m_apoOvrDS.size());
+    }
+
+    GDALRasterBand *GetOverview(int idx) override
+    {
+        auto l_poDS = cpl::down_cast<LIBERTIFFDataset *>(poDS);
+        if (idx >= 0 && idx < GetOverviewCount())
+            return l_poDS->m_apoOvrDS[idx]->GetRasterBand(nBand);
+        return nullptr;
+    }
+
+    int GetMaskFlags() override
+    {
+        return nMaskFlags;
+    }
+
+    GDALRasterBand *GetMaskBand() override
+    {
+        return poMask.get();
+    }
+
+    const char *GetMetadataItem(const char *pszName,
+                                const char *pszDomain) override;
+
+    CPLErr InterpolateAtPoint(double dfPixel, double dfLine,
+                              GDALRIOResampleAlg eInterpolation,
+                              double *pdfRealValue,
+                              double *pdfImagValue = nullptr) const override;
+
+    // We could do a smarter implementation by manually managing blocks in
+    // the TLS structure, but given we should rarely use that method, the
+    // current approach with a mutex should be good enouh
+    GDALRasterBlock *GetLockedBlockRef(int nXBlockOff, int nYBlockOff,
+                                       int bJustInitialize = FALSE) override
+    {
+        if (!m_bDebugGetLockedBlockRef)
+        {
+            m_bDebugGetLockedBlockRef = true;
+            CPLDebug("LIBERTIFF", "GetLockedBlockRef() called");
+        }
+        std::lock_guard oLock(m_oMutexBlockCache);
+        return GDALRasterBand::GetLockedBlockRef(nXBlockOff, nYBlockOff,
+                                                 bJustInitialize);
+    }
+
+    GDALRasterBlock *TryGetLockedBlockRef(int nXBlockOff,
+                                          int nYBlockOff) override
+    {
+        std::lock_guard oLock(m_oMutexBlockCache);
+        return GDALRasterBand::TryGetLockedBlockRef(nXBlockOff, nYBlockOff);
+    }
+
+    CPLErr FlushBlock(int nXBlockOff, int nYBlockOff,
+                      int bWriteDirtyBlock = TRUE) override
+    {
+        std::lock_guard oLock(m_oMutexBlockCache);
+        return GDALRasterBand::FlushBlock(nXBlockOff, nYBlockOff,
+                                          bWriteDirtyBlock);
+    }
+
+  protected:
+    CPLErr IReadBlock(int nBlockXOff, int nBlockYOff, void *pData) override;
+
+    CPLErr IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize,
+                     int nYSize, void *pData, int nBufXSize, int nBufYSize,
+                     GDALDataType eBufType, GSpacing nPixelSpace,
+                     GSpacing nLineSpace,
+                     GDALRasterIOExtraArg *psExtraArg) override
+    {
+        int anBand[] = {nBand};
+        return cpl::down_cast<LIBERTIFFDataset *>(poDS)->IRasterIO(
+            eRWFlag, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize, nBufYSize,
+            eBufType, 1, anBand, nPixelSpace, nLineSpace, 0, psExtraArg);
+    }
+
+  private:
+    friend class LIBERTIFFDataset;
+
+    std::recursive_mutex m_oMutexBlockCache{};
+    GDALColorInterp m_eColorInterp = GCI_Undefined;
+    std::unique_ptr<GDALColorTable> m_poColorTable{};
+    bool m_bHasNoData = false;
+    bool m_bHaveOffsetScale = false;
+    bool m_bDebugGetLockedBlockRef = false;
+    double m_dfNoData = 0;
+    double m_dfScale = 1.0;
+    double m_dfOffset = 0.0;
+    std::string m_osUnitType{};
+    std::string m_osDescription{};
+
+    struct ThreadLocalState
+    {
+      private:
+        std::weak_ptr<int> m_validityTest{};
+
+      public:
+        explicit ThreadLocalState(const LIBERTIFFBand *band)
+            : m_validityTest(
+                  cpl::down_cast<LIBERTIFFDataset *>(band->poDS)->m_validityPtr)
+        {
+        }
+
+        inline bool isValid() const
+        {
+            return m_validityTest.lock() != nullptr;
+        }
+
+        GDALDoublePointsCache m_pointsCache{};
+    };
+
+    ThreadLocalState &GetTLSState() const;
+
+    void ReadColorMap();
+
+    void InitMaskBand();
+};
+
+/************************************************************************/
+/*                           IReadBlock()                               */
+/************************************************************************/
+
+CPLErr LIBERTIFFBand::IReadBlock(int nBlockXOff, int nBlockYOff, void *pData)
+{
+    int nXValid, nYValid;
+    GetActualBlockSize(nBlockXOff, nBlockYOff, &nXValid, &nYValid);
+    GDALRasterIOExtraArg sExtraArg;
+    INIT_RASTERIO_EXTRA_ARG(sExtraArg);
+    int anBand[] = {nBand};
+    const int nDTSize = GDALGetDataTypeSizeBytes(eDataType);
+    return cpl::down_cast<LIBERTIFFDataset *>(poDS)->IRasterIO(
+        GF_Read, nBlockXOff * nBlockXSize, nBlockYOff * nBlockYSize, nXValid,
+        nYValid, pData, nXValid, nYValid, eDataType, 1, anBand, nDTSize,
+        static_cast<GSpacing>(nDTSize) * nBlockXSize, 0, &sExtraArg);
+}
+
+/************************************************************************/
+/*                           ReadColorMap()                             */
+/************************************************************************/
+
+void LIBERTIFFBand::ReadColorMap()
+{
+    auto l_poDS = cpl::down_cast<LIBERTIFFDataset *>(poDS);
+
+    const auto psTagColorMap =
+        l_poDS->m_image->tag(LIBERTIFF_NS::TagCode::ColorMap);
+    if (psTagColorMap && psTagColorMap->type == LIBERTIFF_NS::TagType::Short &&
+        psTagColorMap->count >= 3 && (psTagColorMap->count % 3) == 0 &&
+        psTagColorMap->count == (1U << l_poDS->m_image->bitsPerSample()) * 3U &&
+        !psTagColorMap->invalid_value_offset)
+    {
+        bool ok = true;
+        const auto colorMap =
+            l_poDS->m_image->readTagAsVector<uint16_t>(*psTagColorMap, ok);
+        if (colorMap.size() == psTagColorMap->count)
+        {
+            m_poColorTable = std::make_unique<GDALColorTable>();
+            m_eColorInterp = GCI_PaletteIndex;
+
+            // TIFF color maps are in the [0, 65535] range, so some remapping must
+            // be done to get values in the [0, 255] range, but it is not clear
+            // how to do that exactly. Since GDAL 2.3.0 we have standardized on
+            // using a 257 multiplication factor (https://github.com/OSGeo/gdal/commit/eeec5b62e385d53e7f2edaba7b73c7c74bc2af39)
+            // but other software uses 256 (cf https://github.com/OSGeo/gdal/issues/10310)
+            // Do a first pass to check if all values are multiples of 256 or 257.
+            bool bFoundNonZeroEntry = false;
+            bool bAllValuesMultipleOf256 = true;
+            bool bAllValuesMultipleOf257 = true;
+            unsigned short nMaxColor = 0;
+            int nColorCount = static_cast<int>(psTagColorMap->count / 3);
+            const auto panRed = colorMap.data();
+            const auto panGreen = colorMap.data() + nColorCount;
+            const auto panBlue = colorMap.data() + 2 * nColorCount;
+            for (int iColor = 0; iColor < nColorCount; ++iColor)
+            {
+                if (panRed[iColor] > 0 || panGreen[iColor] > 0 ||
+                    panBlue[iColor] > 0)
+                {
+                    bFoundNonZeroEntry = true;
+                }
+                if ((panRed[iColor] % 256) != 0 ||
+                    (panGreen[iColor] % 256) != 0 ||
+                    (panBlue[iColor] % 256) != 0)
+                {
+                    bAllValuesMultipleOf256 = false;
+                }
+                if ((panRed[iColor] % 257) != 0 ||
+                    (panGreen[iColor] % 257) != 0 ||
+                    (panBlue[iColor] % 257) != 0)
+                {
+                    bAllValuesMultipleOf257 = false;
+                }
+
+                nMaxColor = std::max(nMaxColor, panRed[iColor]);
+                nMaxColor = std::max(nMaxColor, panGreen[iColor]);
+                nMaxColor = std::max(nMaxColor, panBlue[iColor]);
+            }
+
+            int nColorTableMultiplier;
+            if (nMaxColor > 0 && nMaxColor < 256)
+            {
+                // Bug 1384 - Some TIFF files are generated with color map entry
+                // values in range 0-255 instead of 0-65535 - try to handle these
+                // gracefully.
+                nColorTableMultiplier = 1;
+                CPLDebug("GTiff",
+                         "TIFF ColorTable seems to be improperly scaled with "
+                         "values all in [0,255] range, fixing up.");
+            }
+            else
+            {
+                if (!bAllValuesMultipleOf256 && !bAllValuesMultipleOf257)
+                {
+                    CPLDebug("GTiff",
+                             "The color map contains entries which are not "
+                             "multiple of 256 or 257, so we don't know for "
+                             "sure how to remap them to [0, 255]. Default to "
+                             "using a 257 multiplication factor");
+                }
+                constexpr int DEFAULT_COLOR_TABLE_MULTIPLIER_257 = 257;
+                nColorTableMultiplier =
+                    (bFoundNonZeroEntry && bAllValuesMultipleOf256)
+                        ? 256
+                        : DEFAULT_COLOR_TABLE_MULTIPLIER_257;
+            }
+
+            CPLAssert(nColorTableMultiplier > 0);
+            CPLAssert(nColorTableMultiplier <= 257);
+            for (int iColor = nColorCount - 1; iColor >= 0; iColor--)
+            {
+                const GDALColorEntry oEntry = {
+                    static_cast<short>(panRed[iColor] / nColorTableMultiplier),
+                    static_cast<short>(panGreen[iColor] /
+                                       nColorTableMultiplier),
+                    static_cast<short>(panBlue[iColor] / nColorTableMultiplier),
+                    static_cast<short>(
+                        m_bHasNoData && static_cast<int>(m_dfNoData) == iColor
+                            ? 0
+                            : 255)};
+
+                m_poColorTable->SetColorEntry(iColor, &oEntry);
+            }
+        }
+    }
+}
+
+/************************************************************************/
+/*                          GetTLSState()                               */
+/************************************************************************/
+
+LIBERTIFFBand::ThreadLocalState &LIBERTIFFBand::GetTLSState() const
+{
+    static thread_local lru11::Cache<const LIBERTIFFBand *,
+                                     std::shared_ptr<ThreadLocalState>>
+        tlsState;
+    std::shared_ptr<ThreadLocalState> value;
+    if (tlsState.tryGet(this, value))
+    {
+        if (value->isValid())
+            return *value.get();
+    }
+    value = std::make_shared<ThreadLocalState>(this);
+    tlsState.insert(this, value);
+    return *value.get();
+}
+
+/************************************************************************/
+/*                        InterpolateAtPoint()                          */
+/************************************************************************/
+
+CPLErr LIBERTIFFBand::InterpolateAtPoint(double dfPixel, double dfLine,
+                                         GDALRIOResampleAlg eInterpolation,
+                                         double *pdfRealValue,
+                                         double *pdfImagValue) const
+{
+    if (eInterpolation != GRIORA_NearestNeighbour &&
+        eInterpolation != GRIORA_Bilinear && eInterpolation != GRIORA_Cubic &&
+        eInterpolation != GRIORA_CubicSpline)
+    {
+        CPLError(CE_Failure, CPLE_AppDefined,
+                 "Only nearest, bilinear, cubic and cubicspline interpolation "
+                 "methods "
+                 "allowed");
+
+        return CE_Failure;
+    }
+
+    LIBERTIFFBand *pBand = const_cast<LIBERTIFFBand *>(this);
+    auto &pointsCache = GetTLSState().m_pointsCache;
+    const bool res =
+        GDALInterpolateAtPoint(pBand, eInterpolation, pointsCache.cache,
+                               dfPixel, dfLine, pdfRealValue, pdfImagValue);
+
+    return res ? CE_None : CE_Failure;
+}
+
+/************************************************************************/
+/*                           InitMaskBand()                             */
+/************************************************************************/
+
+void LIBERTIFFBand::InitMaskBand()
+{
+    auto l_poDS = cpl::down_cast<LIBERTIFFDataset *>(poDS);
+    if (m_bHasNoData)
+    {
+        nMaskFlags = GMF_NODATA;
+        poMask.reset(std::make_unique<GDALNoDataMaskBand>(this));
+    }
+    else if (l_poDS->m_poMaskDS)
+    {
+        nMaskFlags = GMF_PER_DATASET;
+        poMask.reset(l_poDS->m_poMaskDS->GetRasterBand(1), false);
+    }
+    else if (l_poDS->m_poAlphaBand && l_poDS->m_poAlphaBand != this)
+    {
+        nMaskFlags = GMF_PER_DATASET | GMF_ALPHA;
+        poMask.reset(l_poDS->m_poAlphaBand, false);
+    }
+    else
+    {
+        nMaskFlags = GMF_ALL_VALID;
+        poMask.reset(std::make_unique<GDALAllValidMaskBand>(this));
+    }
+}
+
+/************************************************************************/
+/*                          GetMetadataItem()                           */
+/************************************************************************/
+
+const char *LIBERTIFFBand::GetMetadataItem(const char *pszName,
+                                           const char *pszDomain)
+{
+
+    if (pszName != nullptr && pszDomain != nullptr && EQUAL(pszDomain, "TIFF"))
+    {
+        int nBlockXOff = 0;
+        int nBlockYOff = 0;
+
+        auto l_poDS = cpl::down_cast<LIBERTIFFDataset *>(poDS);
+
+        if (EQUAL(pszName, "JPEGTABLES"))
+        {
+            if (l_poDS->m_jpegTablesOri.empty())
+                return nullptr;
+            char *const pszHex =
+                CPLBinaryToHex(static_cast<int>(l_poDS->m_jpegTablesOri.size()),
+                               l_poDS->m_jpegTablesOri.data());
+            const char *pszReturn = CPLSPrintf("%s", pszHex);
+            CPLFree(pszHex);
+
+            return pszReturn;
+        }
+
+        if (EQUAL(pszName, "IFD_OFFSET"))
+        {
+            return CPLSPrintf(CPL_FRMT_GUIB,
+                              static_cast<GUIntBig>(l_poDS->m_image->offset()));
+        }
+
+        if (sscanf(pszName, "BLOCK_OFFSET_%d_%d", &nBlockXOff, &nBlockYOff) ==
+            2)
+        {
+            if (nBlockXOff < 0 ||
+                nBlockXOff >= DIV_ROUND_UP(nRasterXSize, nBlockXSize) ||
+                nBlockYOff < 0 ||
+                nBlockYOff >= DIV_ROUND_UP(nRasterYSize, nBlockYSize))
+                return nullptr;
+
+            uint64_t curStrileIdx =
+                static_cast<uint64_t>(nBlockYOff) *
+                    DIV_ROUND_UP(nRasterXSize, nBlockXSize) +
+                nBlockXOff;
+            if (l_poDS->m_image->planarConfiguration() ==
+                LIBERTIFF_NS::PlanarConfiguration::Separate)
+            {
+                curStrileIdx += (nBand - 1) *
+                                static_cast<uint64_t>(
+                                    DIV_ROUND_UP(nRasterXSize, nBlockXSize)) *
+                                DIV_ROUND_UP(nRasterYSize, nBlockYSize);
+            }
+
+            bool ok = true;
+            const uint64_t offset =
+                l_poDS->m_image->strileOffset(curStrileIdx, ok);
+            if (!offset)
+            {
+                return nullptr;
+            }
+
+            return CPLSPrintf(CPL_FRMT_GUIB, static_cast<GUIntBig>(offset));
+        }
+
+        if (sscanf(pszName, "BLOCK_SIZE_%d_%d", &nBlockXOff, &nBlockYOff) == 2)
+        {
+            if (nBlockXOff < 0 ||
+                nBlockXOff >= DIV_ROUND_UP(nRasterXSize, nBlockXSize) ||
+                nBlockYOff < 0 ||
+                nBlockYOff >= DIV_ROUND_UP(nRasterYSize, nBlockYSize))
+                return nullptr;
+
+            uint64_t curStrileIdx =
+                static_cast<uint64_t>(nBlockYOff) *
+                    DIV_ROUND_UP(nRasterXSize, nBlockXSize) +
+                nBlockXOff;
+            if (l_poDS->m_image->planarConfiguration() ==
+                LIBERTIFF_NS::PlanarConfiguration::Separate)
+            {
+                curStrileIdx += (nBand - 1) *
+                                static_cast<uint64_t>(
+                                    DIV_ROUND_UP(nRasterXSize, nBlockXSize)) *
+                                DIV_ROUND_UP(nRasterYSize, nBlockYSize);
+            }
+
+            bool ok = true;
+            const uint64_t size =
+                l_poDS->m_image->strileByteCount(curStrileIdx, ok);
+            if (!size)
+            {
+                return nullptr;
+            }
+
+            return CPLSPrintf(CPL_FRMT_GUIB, static_cast<GUIntBig>(size));
+        }
+    }
+    return GDALPamRasterBand::GetMetadataItem(pszName, pszDomain);
+}
+
+/************************************************************************/
+/*                          GetTLSState()                               */
+/************************************************************************/
+
+LIBERTIFFDataset::ThreadLocalState &LIBERTIFFDataset::GetTLSState() const
+{
+    static thread_local lru11::Cache<const LIBERTIFFDataset *,
+                                     std::shared_ptr<ThreadLocalState>>
+        tlsState;
+
+    std::shared_ptr<ThreadLocalState> value;
+    if (tlsState.tryGet(this, value))
+    {
+        if (value->isValid())
+            return *value.get();
+    }
+    value = std::make_shared<ThreadLocalState>(this);
+    tlsState.insert(this, value);
+    return *value.get();
+}
+
+/************************************************************************/
+/*                           IRasterIO()                                */
+/************************************************************************/
+
+CPLErr LIBERTIFFDataset::IRasterIO(
+    GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize,
+    void *pData, int nBufXSize, int nBufYSize, GDALDataType eBufType,
+    int nBandCount, BANDMAP_TYPE panBandMap, GSpacing nPixelSpace,
+    GSpacing nLineSpace, GSpacing nBandSpace, GDALRasterIOExtraArg *psExtraArg)
+{
+    if (eRWFlag != GF_Read)
+        return CE_Failure;
+
+    // Try to pass the request to the most appropriate overview dataset.
+    if (nBufXSize < nXSize && nBufYSize < nYSize)
+    {
+        int bTried = FALSE;
+        const CPLErr eErr = TryOverviewRasterIO(
+            eRWFlag, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize, nBufYSize,
+            eBufType, nBandCount, panBandMap, nPixelSpace, nLineSpace,
+            nBandSpace, psExtraArg, &bTried);
+        if (bTried)
+            return eErr;
+    }
+
+    const GDALDataType eNativeDT = papoBands[0]->GetRasterDataType();
+    const size_t nNativeDTSize =
+        static_cast<size_t>(GDALGetDataTypeSizeBytes(eNativeDT));
+    int nBlockXSize, nBlockYSize;
+    papoBands[0]->GetBlockSize(&nBlockXSize, &nBlockYSize);
+
+    const int iXBlockMin = nXOff / nBlockXSize;
+    const int iYBlockMin = nYOff / nBlockYSize;
+    if (nXSize == 1 && nYSize == 1 && nBufXSize == 1 && nBufYSize == 1)
+    {
+        ThreadLocalState &tlsState = GetTLSState();
+        const double dfNoData =
+            cpl::down_cast<LIBERTIFFBand *>(papoBands[0])->m_dfNoData;
+        const size_t nXYOffset =
+            static_cast<size_t>(nYOff % nBlockYSize) * nBlockXSize +
+            (nXOff % nBlockXSize);
+        if (m_image->planarConfiguration() ==
+            LIBERTIFF_NS::PlanarConfiguration::Separate)
+        {
+            for (int iBand = 0; iBand < nBandCount; ++iBand)
+            {
+                int anBand[] = {panBandMap[iBand]};
+                if (!ReadBlock(nullptr, iXBlockMin, iYBlockMin, 1, anBand,
+                               eBufType, nPixelSpace, nLineSpace, nBandSpace))
+                {
+                    return CE_Failure;
+                }
+                if (tlsState.m_curStrileMissing)
+                {
+                    GDALCopyWords64(&dfNoData, GDT_Float64, 0,
+                                    static_cast<GByte *>(pData) +
+                                        iBand * nBandSpace,
+                                    eBufType, 0, 1);
+                }
+                else
+                {
+                    GDALCopyWords64(tlsState.m_decompressedBuffer.data() +
+                                        nNativeDTSize * nXYOffset,
+                                    eNativeDT, 0,
+                                    static_cast<GByte *>(pData) +
+                                        iBand * nBandSpace,
+                                    eBufType, 0, 1);
+                }
+            }
+        }
+        else
+        {
+            if (!ReadBlock(nullptr, iXBlockMin, iYBlockMin, nBandCount,
+                           panBandMap, eBufType, nPixelSpace, nLineSpace,
+                           nBandSpace))
+            {
+                return CE_Failure;
+            }
+            for (int iBand = 0; iBand < nBandCount; ++iBand)
+            {
+                if (tlsState.m_curStrileMissing)
+                {
+                    GDALCopyWords64(&dfNoData, GDT_Float64, 0,
+                                    static_cast<GByte *>(pData) +
+                                        iBand * nBandSpace,
+                                    eBufType, 0, 1);
+                }
+                else
+                {
+                    GDALCopyWords64(
+                        tlsState.m_decompressedBuffer.data() +
+                            nNativeDTSize *
+                                (panBandMap[iBand] - 1 + nXYOffset * nBands),
+                        eNativeDT, 0,
+                        static_cast<GByte *>(pData) + iBand * nBandSpace,
+                        eBufType, 0, 1);
+                }
+            }
+        }
+        return CE_None;
+    }
+
+    // Check that request is full resolution and aligned on block boundaries
+    // (with the exception of the right and bottom most blocks that can be
+    // truncated)
+    if (nXSize != nBufXSize || nYSize != nBufYSize ||
+        (nXOff % nBlockXSize) != 0 || (nYOff % nBlockYSize) != 0 ||
+        !(nXOff + nXSize == nRasterXSize || (nBufXSize % nBlockXSize) == 0) ||
+        !(nYOff + nYSize == nRasterYSize || (nBufYSize % nBlockYSize) == 0))
+    {
+        const int nXOffMod = (nXOff / nBlockXSize) * nBlockXSize;
+        const int nYOffMod = (nYOff / nBlockYSize) * nBlockYSize;
+        const int nXOff2Mod = static_cast<int>(std::min(
+            static_cast<int64_t>(nRasterXSize),
+            static_cast<int64_t>(DIV_ROUND_UP(nXOff + nXSize, nBlockXSize)) *
+                nBlockXSize));
+        const int nYOff2Mod = static_cast<int>(std::min(
+            static_cast<int64_t>(nRasterYSize),
+            static_cast<int64_t>(DIV_ROUND_UP(nYOff + nYSize, nBlockYSize)) *
+                nBlockYSize));
+        const int nXSizeMod = nXOff2Mod - nXOffMod;
+        const int nYSizeMod = nYOff2Mod - nYOffMod;
+        std::vector<GByte> &abyTmp = GetTLSState().m_abyIRasterIOBuffer;
+
+        try
+        {
+            if (nNativeDTSize * nBandCount >
+                std::numeric_limits<size_t>::max() /
+                    (static_cast<uint64_t>(nXSizeMod) * nYSizeMod))
+            {
+                CPLError(CE_Failure, CPLE_OutOfMemory,
+                         "Out of memory allocating temporary buffer");
+                return CE_Failure;
+            }
+            const size_t nSize =
+                nNativeDTSize * nBandCount * nXSizeMod * nYSizeMod;
+            if (abyTmp.size() < nSize)
+                abyTmp.resize(nSize);
+        }
+        catch (const std::exception &)
+        {
+            CPLError(CE_Failure, CPLE_OutOfMemory,
+                     "Out of memory allocating temporary buffer");
+            return CE_Failure;
+        }
+
+        {
+            GDALRasterIOExtraArg sExtraArg;
+            INIT_RASTERIO_EXTRA_ARG(sExtraArg);
+
+            if (IRasterIO(GF_Read, nXOffMod, nYOffMod, nXSizeMod, nYSizeMod,
+                          abyTmp.data(), nXSizeMod, nYSizeMod, eNativeDT,
+                          nBandCount, panBandMap,
+                          GDALGetDataTypeSizeBytes(eNativeDT),
+                          nNativeDTSize * nXSizeMod,
+                          nNativeDTSize * nXSizeMod * nYSizeMod,
+                          &sExtraArg) != CE_None)
+            {
+                return CE_Failure;
+            }
+        }
+
+        auto poMEMDS = std::unique_ptr<MEMDataset>(MEMDataset::Create(
+            "", nXSizeMod, nYSizeMod, 0, GDT_Unknown, nullptr));
+        if (!poMEMDS)
+        {
+            return CE_Failure;
+        }
+        for (int i = 0; i < nBandCount; ++i)
+        {
+            GByte *pabyData =
+                abyTmp.data() + i * nNativeDTSize * nXSizeMod * nYSizeMod;
+            GDALRasterBandH hMEMBand = MEMCreateRasterBandEx(
+                poMEMDS.get(), i + 1, pabyData, eNativeDT, nNativeDTSize,
+                nNativeDTSize * nXSizeMod, false);
+            poMEMDS->AddMEMBand(hMEMBand);
+        }
+
+        GDALRasterIOExtraArg sExtraArg;
+        INIT_RASTERIO_EXTRA_ARG(sExtraArg);
+        // cppcheck-suppress redundantAssignment
+        sExtraArg.eResampleAlg = psExtraArg->eResampleAlg;
+        sExtraArg.bFloatingPointWindowValidity =
+            psExtraArg->bFloatingPointWindowValidity;
+        if (sExtraArg.bFloatingPointWindowValidity)
+        {
+            sExtraArg.dfXOff = psExtraArg->dfXOff - nXOffMod;
+            sExtraArg.dfYOff = psExtraArg->dfYOff - nYOffMod;
+            sExtraArg.dfXSize = psExtraArg->dfXSize;
+            sExtraArg.dfYSize = psExtraArg->dfYSize;
+        }
+        return poMEMDS->RasterIO(GF_Read, nXOff - nXOffMod, nYOff - nYOffMod,
+                                 nXSize, nYSize, pData, nBufXSize, nBufYSize,
+                                 eBufType, nBandCount, nullptr, nPixelSpace,
+                                 nLineSpace, nBandSpace, &sExtraArg);
+    }
+
+    const int iYBlockMax = DIV_ROUND_UP(nYOff + nBufYSize, nBlockYSize);
+    const int iXBlockMax = DIV_ROUND_UP(nXOff + nBufXSize, nBlockXSize);
+
+    // Could be parallelized
+    for (int iYBlock = iYBlockMin, iY = 0; iYBlock < iYBlockMax;
+         ++iYBlock, ++iY)
+    {
+        for (int iXBlock = iXBlockMin, iX = 0; iXBlock < iXBlockMax;
+             ++iXBlock, ++iX)
+        {
+            if (m_image->planarConfiguration() ==
+                LIBERTIFF_NS::PlanarConfiguration::Separate)
+            {
+                for (int iBand = 0; iBand < nBandCount; ++iBand)
+                {
+                    int anBand[] = {panBandMap[iBand]};
+                    if (!ReadBlock(static_cast<GByte *>(pData) +
+                                       iY * nLineSpace * nBlockYSize +
+                                       iX * nPixelSpace * nBlockXSize +
+                                       iBand * nBandSpace,
+                                   iXBlock, iYBlock, 1, anBand, eBufType,
+                                   nPixelSpace, nLineSpace, nBandSpace))
+                    {
+                        return CE_Failure;
+                    }
+                }
+            }
+            else
+            {
+                if (!ReadBlock(static_cast<GByte *>(pData) +
+                                   iY * nLineSpace * nBlockYSize +
+                                   iX * nPixelSpace * nBlockXSize,
+                               iXBlock, iYBlock, nBandCount, panBandMap,
+                               eBufType, nPixelSpace, nLineSpace, nBandSpace))
+                {
+                    return CE_Failure;
+                }
+            }
+        }
+    }
+
+    return CE_None;
+}
+
+/************************************************************************/
+/*                       HorizPredictorDecode()                         */
+/************************************************************************/
+
+template <class T, class U>
+CPL_NOSANITIZE_UNSIGNED_INT_OVERFLOW static void
+HorizPredictorDecode1Component(void *bufferIn, size_t nPixelCount)
+{
+    T *buffer = static_cast<T *>(bufferIn);
+    constexpr T mask = std::numeric_limits<T>::max();
+    U acc = buffer[0];
+    size_t i = 1;
+    for (; i + 3 < nPixelCount; i += 4)
+    {
+        acc += buffer[i];
+        buffer[i] = static_cast<T>(acc & mask);
+        acc += buffer[i + 1];
+        buffer[i + 1] = static_cast<T>(acc & mask);
+        acc += buffer[i + 2];
+        buffer[i + 2] = static_cast<T>(acc & mask);
+        acc += buffer[i + 3];
+        buffer[i + 3] = static_cast<T>(acc & mask);
+    }
+    for (; i < nPixelCount; ++i)
+    {
+        acc += buffer[i];
+        buffer[i] = static_cast<T>(acc & mask);
+    }
+}
+
+template <class T, class U>
+CPL_NOSANITIZE_UNSIGNED_INT_OVERFLOW static void
+HorizPredictorDecode2Components(void *bufferIn, size_t nPixelCount)
+{
+    T *buffer = static_cast<T *>(bufferIn);
+    constexpr T mask = std::numeric_limits<T>::max();
+    U acc0 = buffer[0];
+    U acc1 = buffer[1];
+    for (size_t i = 1; i < nPixelCount; ++i)
+    {
+        acc0 += buffer[i * 2 + 0];
+        acc1 += buffer[i * 2 + 1];
+        buffer[i * 2 + 0] = static_cast<T>(acc0 & mask);
+        buffer[i * 2 + 1] = static_cast<T>(acc1 & mask);
+    }
+}
+
+template <class T, class U>
+CPL_NOSANITIZE_UNSIGNED_INT_OVERFLOW static void
+HorizPredictorDecode3Components(void *bufferIn, size_t nPixelCount)
+{
+    T *buffer = static_cast<T *>(bufferIn);
+    constexpr T mask = std::numeric_limits<T>::max();
+    U acc0 = buffer[0];
+    U acc1 = buffer[1];
+    U acc2 = buffer[2];
+    for (size_t i = 1; i < nPixelCount; ++i)
+    {
+        acc0 += buffer[i * 3 + 0];
+        acc1 += buffer[i * 3 + 1];
+        acc2 += buffer[i * 3 + 2];
+        buffer[i * 3 + 0] = static_cast<T>(acc0 & mask);
+        buffer[i * 3 + 1] = static_cast<T>(acc1 & mask);
+        buffer[i * 3 + 2] = static_cast<T>(acc2 & mask);
+    }
+}
+
+template <class T, class U>
+CPL_NOSANITIZE_UNSIGNED_INT_OVERFLOW static void
+HorizPredictorDecode4Components(void *bufferIn, size_t nPixelCount)
+{
+    T *buffer = static_cast<T *>(bufferIn);
+    constexpr T mask = std::numeric_limits<T>::max();
+    U acc0 = buffer[0];
+    U acc1 = buffer[1];
+    U acc2 = buffer[2];
+    U acc3 = buffer[3];
+    for (size_t i = 1; i < nPixelCount; ++i)
+    {
+        acc0 += buffer[i * 4 + 0];
+        acc1 += buffer[i * 4 + 1];
+        acc2 += buffer[i * 4 + 2];
+        acc3 += buffer[i * 4 + 3];
+        buffer[i * 4 + 0] = static_cast<T>(acc0 & mask);
+        buffer[i * 4 + 1] = static_cast<T>(acc1 & mask);
+        buffer[i * 4 + 2] = static_cast<T>(acc2 & mask);
+        buffer[i * 4 + 3] = static_cast<T>(acc3 & mask);
+    }
+}
+
+template <class T>
+CPL_NOSANITIZE_UNSIGNED_INT_OVERFLOW static void
+HorizPredictorDecode(void *bufferIn, size_t nPixelCount,
+                     int nComponentsPerPixel)
+{
+    static_assert(std::is_same_v<T, uint8_t> || std::is_same_v<T, uint16_t> ||
+                  std::is_same_v<T, uint32_t> || std::is_same_v<T, uint64_t>);
+
+    if (nComponentsPerPixel == 1)
+    {
+        // cppcheck-suppress duplicateBranch
+        if constexpr (sizeof(T) < sizeof(uint64_t))
+        {
+            HorizPredictorDecode1Component<T, uint32_t>(bufferIn, nPixelCount);
+        }
+        else
+        {
+            HorizPredictorDecode1Component<T, T>(bufferIn, nPixelCount);
+        }
+    }
+    else if (nComponentsPerPixel == 2)
+    {
+        // cppcheck-suppress duplicateBranch
+        if constexpr (sizeof(T) < sizeof(uint64_t))
+        {
+            HorizPredictorDecode2Components<T, uint32_t>(bufferIn, nPixelCount);
+        }
+        else
+        {
+            HorizPredictorDecode2Components<T, T>(bufferIn, nPixelCount);
+        }
+    }
+    else if (nComponentsPerPixel == 3)
+    {
+        // cppcheck-suppress duplicateBranch
+        if constexpr (sizeof(T) < sizeof(uint64_t))
+        {
+            HorizPredictorDecode3Components<T, uint32_t>(bufferIn, nPixelCount);
+        }
+        else
+        {
+            HorizPredictorDecode3Components<T, T>(bufferIn, nPixelCount);
+        }
+    }
+    else if (nComponentsPerPixel == 4)
+    {
+        // cppcheck-suppress duplicateBranch
+        if constexpr (sizeof(T) < sizeof(uint64_t))
+        {
+            HorizPredictorDecode4Components<T, uint32_t>(bufferIn, nPixelCount);
+        }
+        else
+        {
+            HorizPredictorDecode4Components<T, T>(bufferIn, nPixelCount);
+        }
+    }
+    else
+    {
+        T *buffer = static_cast<T *>(bufferIn);
+        constexpr T mask = std::numeric_limits<T>::max();
+        for (size_t i = 1; i < nPixelCount; ++i)
+        {
+            for (int j = 0; j < nComponentsPerPixel; j++)
+            {
+                buffer[i * nComponentsPerPixel + j] =
+                    static_cast<T>((buffer[i * nComponentsPerPixel + j] +
+                                    buffer[(i - 1) * nComponentsPerPixel + j]) &
+                                   mask);
+            }
+        }
+    }
+}
+
+/************************************************************************/
+/*                FloatingPointHorizPredictorDecode()                   */
+/************************************************************************/
+
+template <class T>
+CPL_NOSANITIZE_UNSIGNED_INT_OVERFLOW static bool
+FloatingPointHorizPredictorDecode(std::vector<uint8_t> &tmpBuffer,
+                                  void *bufferIn, size_t nPixelCount,
+                                  int nComponentsPerPixel)
+{
+    uint8_t *buffer = static_cast<uint8_t *>(bufferIn);
+    HorizPredictorDecode<uint8_t>(buffer, nPixelCount * sizeof(T),
+                                  nComponentsPerPixel);
+
+    const size_t tmpBufferSize = nPixelCount * nComponentsPerPixel * sizeof(T);
+    if (tmpBuffer.size() < tmpBufferSize)
+    {
+        try
+        {
+            tmpBuffer.resize(tmpBufferSize);
+        }
+        catch (const std::exception &)
+        {
+            CPLError(CE_Failure, CPLE_OutOfMemory,
+                     "Out of memory in FloatingPointHorizPredictorDecode()");
+            return false;
+        }
+    }
+    memcpy(tmpBuffer.data(), buffer, tmpBufferSize);
+    constexpr uint32_t bytesPerWords = static_cast<uint32_t>(sizeof(T));
+    const size_t wordCount = nPixelCount * nComponentsPerPixel;
+    for (size_t iWord = 0; iWord < wordCount; iWord++)
+    {
+        for (uint32_t iByte = 0; iByte < bytesPerWords; iByte++)
+        {
+#ifdef CPL_MSB
+            buffer[bytesPerWords * iWord + iByte] =
+                tmpBuffer[iByte * wordCount + iWord];
+#else
+            buffer[bytesPerWords * iWord + iByte] =
+                tmpBuffer[(bytesPerWords - iByte - 1) * wordCount + iWord];
+#endif
+        }
+    }
+    return true;
+}
+
+/************************************************************************/
+/*                     ExtractBitAndConvertTo255()                      */
+/************************************************************************/
+
+#if defined(__GNUC__) || defined(_MSC_VER)
+// Signedness of char implementation dependent, so be explicit.
+// Assumes 2-complement integer types and sign extension of right shifting
+// GCC guarantees such:
+// https://gcc.gnu.org/onlinedocs/gcc/Integers-implementation.html#Integers-implementation
+static inline GByte ExtractBitAndConvertTo255(GByte byVal, int nBit)
+{
+    return static_cast<GByte>(static_cast<signed char>(byVal << (7 - nBit)) >>
+                              7);
+}
+#else
+// Portable way
+static inline GByte ExtractBitAndConvertTo255(GByte byVal, int nBit)
+{
+    return (byVal & (1 << nBit)) ? 255 : 0;
+}
+#endif
+
+/************************************************************************/
+/*                           ReadBlock()                                */
+/************************************************************************/
+
+bool LIBERTIFFDataset::ReadBlock(GByte *pabyBlockData, int nBlockXOff,
+                                 int nBlockYOff, int nBandCount,
+                                 BANDMAP_TYPE panBandMap, GDALDataType eBufType,
+                                 GSpacing nPixelSpace, GSpacing nLineSpace,
+                                 GSpacing nBandSpace) const
+{
+    uint64_t offset = 0;
+    size_t size = 0;
+    const bool bSeparate = m_image->planarConfiguration() ==
+                           LIBERTIFF_NS::PlanarConfiguration::Separate;
+
+    ThreadLocalState &tlsState = GetTLSState();
+
+    const int iBandTIFFFirst = bSeparate ? panBandMap[0] - 1 : 0;
+    uint64_t curStrileIdx;
+    if (m_image->isTiled())
+    {
+        bool ok = true;
+        curStrileIdx = m_image->tileCoordinateToIdx(nBlockXOff, nBlockYOff,
+                                                    iBandTIFFFirst, ok);
+    }
+    else
+    {
+        if (bSeparate)
+            curStrileIdx =
+                nBlockYOff + DIV_ROUND_UP(m_image->height(),
+                                          m_image->rowsPerStripSanitized()) *
+                                 iBandTIFFFirst;
+        else
+            curStrileIdx = nBlockYOff;
+    }
+    if (curStrileIdx != tlsState.m_curStrileIdx)
+    {
+        bool ok = true;
+        offset = curStrileIdx < m_tileOffsets.size()
+                     ? m_tileOffsets[static_cast<size_t>(curStrileIdx)]
+                 : curStrileIdx < m_tileOffsets64.size()
+                     ? m_tileOffsets64[static_cast<size_t>(curStrileIdx)]
+                     : m_image->strileOffset(curStrileIdx, ok);
+        if (!ok)
+        {
+            CPLError(CE_Failure, CPLE_AppDefined, "Cannot read strile offset");
+            return false;
+        }
+        const uint64_t size64 =
+            curStrileIdx < m_tileByteCounts.size()
+                ? m_tileByteCounts[static_cast<size_t>(curStrileIdx)]
+                : m_image->strileByteCount(curStrileIdx, ok);
+        if (!ok)
+        {
+            CPLError(CE_Failure, CPLE_AppDefined, "Cannot read strile size");
+            return false;
+        }
+
+        if constexpr (sizeof(size_t) < sizeof(uint64_t))
+        {
+            if (size64 > std::numeric_limits<size_t>::max())
+            {
+                CPLError(CE_Failure, CPLE_NotSupported, "Too large strile");
+                return false;
+            }
+        }
+        size = static_cast<size_t>(size64);
+        // Avoid doing non-sensical memory allocations
+        constexpr size_t THRESHOLD_CHECK_FILE_SIZE = 10 * 1024 * 1024;
+        if (size > THRESHOLD_CHECK_FILE_SIZE &&
+            size > m_image->readContext()->size())
+        {
+            CPLError(CE_Failure, CPLE_NotSupported,
+                     "Strile size larger than file size");
+            return false;
+        }
+    }
+
+    const GDALDataType eNativeDT = papoBands[0]->GetRasterDataType();
+    int nBlockXSize, nBlockYSize;
+    papoBands[0]->GetBlockSize(&nBlockXSize, &nBlockYSize);
+    const int nBlockActualXSize =
+        std::min(nBlockXSize, nRasterXSize - nBlockXOff * nBlockXSize);
+    const int nBlockActualYSize =
+        std::min(nBlockYSize, nRasterYSize - nBlockYOff * nBlockYSize);
+
+    // Sparse block?
+    if ((curStrileIdx != tlsState.m_curStrileIdx && size == 0) ||
+        (curStrileIdx == tlsState.m_curStrileIdx &&
+         tlsState.m_curStrileMissing))
+    {
+        if (pabyBlockData)
+        {
+            const double dfNoData =
+                cpl::down_cast<LIBERTIFFBand *>(papoBands[0])->m_dfNoData;
+            for (int iBand = 0; iBand < nBandCount; ++iBand)
+            {
+                for (int iY = 0; iY < nBlockActualYSize; ++iY)
+                {
+                    GDALCopyWords64(&dfNoData, GDT_Float64, 0,
+                                    pabyBlockData + iBand * nBandSpace +
+                                        iY * nLineSpace,
+                                    eBufType, static_cast<int>(nPixelSpace),
+                                    nBlockActualXSize);
+                }
+            }
+        }
+
+        tlsState.m_curStrileIdx = curStrileIdx;
+        tlsState.m_curStrileMissing = true;
+        return true;
+    }
+
+    std::vector<GByte> &abyDecompressedStrile = tlsState.m_decompressedBuffer;
+    const size_t nNativeDTSize =
+        static_cast<size_t>(GDALGetDataTypeSizeBytes(eNativeDT));
+
+    if (curStrileIdx != tlsState.m_curStrileIdx)
+    {
+        std::vector<GByte> &bufferForOneBitExpansion =
+            tlsState.m_bufferForOneBitExpansion;
+
+        // Overflow in multiplication checked in Open() method
+        const int nComponentsPerPixel = bSeparate ? 1 : nBands;
+        const size_t nActualPixelCount =
+            static_cast<size_t>(m_image->isTiled() ? nBlockYSize
+                                                   : nBlockActualYSize) *
+            nBlockXSize;
+        const int nLineSizeBytes =
+            m_image->bitsPerSample() == 1 ? (nBlockXSize + 7) / 8 : nBlockXSize;
+        const size_t nActualUncompressedSize =
+            nNativeDTSize *
+            static_cast<size_t>(m_image->isTiled() ? nBlockYSize
+                                                   : nBlockActualYSize) *
+            nLineSizeBytes * nComponentsPerPixel;
+
+        // Allocate buffer for decompressed strile
+        if (abyDecompressedStrile.empty())
+        {
+            const size_t nMaxUncompressedSize =
+                nNativeDTSize * nBlockXSize * nBlockYSize * nComponentsPerPixel;
+            try
+            {
+                abyDecompressedStrile.resize(nMaxUncompressedSize);
+                if (m_image->bitsPerSample() == 1)
+                    bufferForOneBitExpansion.resize(nMaxUncompressedSize);
+            }
+            catch (const std::exception &)
+            {
+                CPLError(CE_Failure, CPLE_OutOfMemory,
+                         "Out of memory allocating temporary buffer");
+                return false;
+            }
+        }
+
+        if (m_image->compression() != LIBERTIFF_NS::Compression::None)
+        {
+            std::vector<GByte> &abyCompressedStrile =
+                tlsState.m_compressedBuffer;
+            if (size > 128 && size / 16 > nActualUncompressedSize)
+            {
+                CPLError(CE_Failure, CPLE_AppDefined,
+                         "Compressed strile size is much larger than "
+                         "uncompressed size");
+                return false;
+            }
+            if (abyCompressedStrile.size() < size + m_jpegTables.size())
+            {
+                try
+                {
+                    abyCompressedStrile.resize(size + m_jpegTables.size());
+                }
+                catch (const std::exception &)
+                {
+                    CPLError(CE_Failure, CPLE_OutOfMemory,
+                             "Out of memory allocating temporary buffer");
+                    return false;
+                }
+            }
+
+            bool ok = true;
+            m_image->readContext()->read(offset, size,
+                                         abyCompressedStrile.data(), ok);
+            if (!ok)
+            {
+                CPLError(CE_Failure, CPLE_FileIO,
+                         "Cannot read strile from disk");
+                return false;
+            }
+
+            if (!tlsState.m_tiff.tif_decodestrip)
+            {
+                if (m_image->compression() == LIBERTIFF_NS::Compression::LZW)
+                {
+                    TIFFInitLZW(&tlsState.m_tiff, m_image->compression());
+                }
+                else if (m_image->compression() ==
+                         LIBERTIFF_NS::Compression::PackBits)
+                {
+                    TIFFInitPackBits(&tlsState.m_tiff, m_image->compression());
+                }
+#ifdef LERC_SUPPORT
+                else if (m_image->compression() ==
+                         LIBERTIFF_NS::Compression::LERC)
+                {
+                    TIFFInitLERC(&tlsState.m_tiff, m_image->compression());
+                    LERCState *sp =
+                        reinterpret_cast<LERCState *>(tlsState.m_tiff.tif_data);
+                    sp->lerc_version = m_lercVersion;
+                    sp->additional_compression = m_lercAdditionalCompression;
+                }
+#endif
+
+                if (tlsState.m_tiff.tif_decodestrip)
+                {
+                    tlsState.m_tiff.tif_dir.td_sampleformat =
+                        static_cast<uint16_t>(m_image->sampleFormat());
+                    tlsState.m_tiff.tif_dir.td_bitspersample =
+                        static_cast<uint16_t>(m_image->bitsPerSample());
+                    if (m_image->isTiled())
+                    {
+                        tlsState.m_tiff.tif_flags = TIFF_ISTILED;
+                        tlsState.m_tiff.tif_dir.td_tilewidth =
+                            m_image->tileWidth();
+                        tlsState.m_tiff.tif_dir.td_tilelength =
+                            m_image->tileHeight();
+                    }
+                    else
+                    {
+                        tlsState.m_tiff.tif_dir.td_imagewidth =
+                            m_image->width();
+                        tlsState.m_tiff.tif_dir.td_imagelength =
+                            m_image->height();
+                        tlsState.m_tiff.tif_dir.td_rowsperstrip =
+                            m_image->rowsPerStripSanitized();
+                    }
+                    tlsState.m_tiff.tif_dir.td_samplesperpixel =
+                        static_cast<uint16_t>(m_image->samplesPerPixel());
+                    tlsState.m_tiff.tif_dir.td_planarconfig =
+                        static_cast<uint16_t>(m_image->planarConfiguration());
+                    if (m_extraSamples.size() < 65536)
+                    {
+                        tlsState.m_tiff.tif_dir.td_extrasamples =
+                            static_cast<uint16_t>(m_extraSamples.size());
+                        tlsState.m_tiff.tif_dir.td_sampleinfo =
+                            const_cast<uint16_t *>(m_extraSamples.data());
+                    }
+                }
+            }
+
+            if (tlsState.m_tiff.tif_decodestrip)
+            {
+                tlsState.m_tiff.tif_row = nBlockYOff * nBlockYSize;
+                tlsState.m_tiff.tif_rawcc = size;
+                tlsState.m_tiff.tif_rawdata = abyCompressedStrile.data();
+                tlsState.m_tiff.tif_rawcp = tlsState.m_tiff.tif_rawdata;
+                if ((tlsState.m_tiff.tif_predecode &&
+                     tlsState.m_tiff.tif_predecode(&tlsState.m_tiff, 0) == 0) ||
+                    tlsState.m_tiff.tif_decodestrip(
+                        &tlsState.m_tiff, abyDecompressedStrile.data(),
+                        nActualUncompressedSize, 0) == 0)
+                {
+                    CPLError(CE_Failure, CPLE_AppDefined,
+                             "Decompression failed");
+                    return false;
+                }
+            }
+            else if (m_image->compression() ==
+                         LIBERTIFF_NS::Compression::JPEG ||
+                     m_image->compression() ==
+                         LIBERTIFF_NS::Compression::WEBP ||
+                     m_image->compression() == LIBERTIFF_NS::Compression::JXL ||
+                     m_image->compression() ==
+                         LIBERTIFF_NS::Compression::JXL_DNG_1_7)
+            {
+                size_t blobSize = size;
+                const char *drvName =
+                    m_image->compression() == LIBERTIFF_NS::Compression::JPEG
+                        ? "JPEG"
+                    : m_image->compression() == LIBERTIFF_NS::Compression::WEBP
+                        ? "WEBP"
+                        : "JPEGXL";
+                if (m_image->compression() == LIBERTIFF_NS::Compression::JPEG &&
+                    size > 2 && !m_jpegTables.empty())
+                {
+                    // Insert JPEG tables into JPEG blob
+                    memmove(abyCompressedStrile.data() + 2 +
+                                m_jpegTables.size(),
+                            abyCompressedStrile.data() + 2, size - 2);
+                    memcpy(abyCompressedStrile.data() + 2, m_jpegTables.data(),
+                           m_jpegTables.size());
+                    blobSize += m_jpegTables.size();
+                }
+                const std::string osTmpFilename = VSIMemGenerateHiddenFilename(
+                    std::string("tmp.").append(drvName).c_str());
+                VSIFCloseL(VSIFileFromMemBuffer(
+                    osTmpFilename.c_str(), abyCompressedStrile.data(), blobSize,
+                    /* bTakeOwnership = */ false));
+                const char *const apszAllowedDrivers[] = {drvName, nullptr};
+
+                CPLConfigOptionSetter oJPEGtoRGBSetter(
+                    "GDAL_JPEG_TO_RGB",
+                    m_image->compression() == LIBERTIFF_NS::Compression::JPEG &&
+                            m_image->samplesPerPixel() == 4 &&
+                            m_image->planarConfiguration() ==
+                                LIBERTIFF_NS::PlanarConfiguration::Contiguous
+                        ? "NO"
+                        : "YES",
+                    false);
+
+                auto poTmpDS = std::unique_ptr<GDALDataset>(GDALDataset::Open(
+                    osTmpFilename.c_str(), GDAL_OF_RASTER | GDAL_OF_INTERNAL,
+                    apszAllowedDrivers, nullptr, nullptr));
+                VSIUnlink(osTmpFilename.c_str());
+                if (!poTmpDS)
+                {
+                    CPLError(CE_Failure, CPLE_AppDefined, "Not a %s blob",
+                             drvName);
+                    return false;
+                }
+                if (poTmpDS->GetRasterCount() != nComponentsPerPixel ||
+                    poTmpDS->GetRasterXSize() != nBlockXSize ||
+                    poTmpDS->GetRasterYSize() !=
+                        (m_image->isTiled() ? nBlockYSize : nBlockActualYSize))
+                {
+                    CPLError(CE_Failure, CPLE_AppDefined,
+                             "%s blob has no expected dimensions (%dx%d "
+                             "whereas %dx%d expected) or band count (%d "
+                             "whereas %d expected)",
+                             drvName, poTmpDS->GetRasterXSize(),
+                             poTmpDS->GetRasterYSize(), nBlockXSize,
+                             m_image->isTiled() ? nBlockYSize
+                                                : nBlockActualYSize,
+                             poTmpDS->GetRasterCount(), nComponentsPerPixel);
+                    return false;
+                }
+                GDALRasterIOExtraArg sExtraArg;
+                INIT_RASTERIO_EXTRA_ARG(sExtraArg);
+                if (poTmpDS->RasterIO(
+                        GF_Read, 0, 0, poTmpDS->GetRasterXSize(),
+                        poTmpDS->GetRasterYSize(), abyDecompressedStrile.data(),
+                        poTmpDS->GetRasterXSize(), poTmpDS->GetRasterYSize(),
+                        eNativeDT, poTmpDS->GetRasterCount(), nullptr,
+                        nNativeDTSize * nComponentsPerPixel,
+                        nNativeDTSize * nComponentsPerPixel * nBlockXSize,
+                        nNativeDTSize, &sExtraArg) != CE_None)
+                {
+                    CPLError(CE_Failure, CPLE_AppDefined,
+                             "Decompression failed");
+                    return false;
+                }
+            }
+            else
+            {
+                CPLAssert(m_decompressor);
+                void *output_data = abyDecompressedStrile.data();
+                size_t output_size = nActualUncompressedSize;
+                if (!m_decompressor->pfnFunc(
+                        abyCompressedStrile.data(), size, &output_data,
+                        &output_size, nullptr, m_decompressor->user_data) ||
+                    output_size != nActualUncompressedSize)
+                {
+                    CPLError(CE_Failure, CPLE_AppDefined,
+                             "Decompression failed");
+                    return false;
+                }
+                CPLAssert(output_data == abyDecompressedStrile.data());
+            }
+        }
+        else
+        {
+            if (size != nActualUncompressedSize)
+            {
+                CPLError(CE_Failure, CPLE_NotSupported,
+                         "Strile size != expected size");
+                return false;
+            }
+
+            bool ok = true;
+            m_image->readContext()->read(offset, size,
+                                         abyDecompressedStrile.data(), ok);
+            if (!ok)
+            {
+                CPLError(CE_Failure, CPLE_FileIO,
+                         "Cannot read strile from disk");
+                return false;
+            }
+        }
+
+        if (m_image->bitsPerSample() == 1)
+        {
+            const GByte *CPL_RESTRICT pabySrc = abyDecompressedStrile.data();
+            const GByte val = m_bExpand1To255 ? 255 : 1;
+            GByte *CPL_RESTRICT pabyDst = bufferForOneBitExpansion.data();
+            for (int iY = 0; iY < nBlockActualYSize; ++iY)
+            {
+                int iX = 0;
+                if (m_bExpand1To255)
+                {
+                    for (; iX + 7 < nBlockXSize;
+                         iX += 8, ++pabySrc, pabyDst += 8)
+                    {
+                        const GByte srcByte = *pabySrc;
+                        pabyDst[0] = ExtractBitAndConvertTo255(srcByte, 7);
+                        pabyDst[1] = ExtractBitAndConvertTo255(srcByte, 6);
+                        pabyDst[2] = ExtractBitAndConvertTo255(srcByte, 5);
+                        pabyDst[3] = ExtractBitAndConvertTo255(srcByte, 4);
+                        pabyDst[4] = ExtractBitAndConvertTo255(srcByte, 3);
+                        pabyDst[5] = ExtractBitAndConvertTo255(srcByte, 2);
+                        pabyDst[6] = ExtractBitAndConvertTo255(srcByte, 1);
+                        pabyDst[7] = ExtractBitAndConvertTo255(srcByte, 0);
+                    }
+                }
+                else
+                {
+                    for (; iX + 7 < nBlockXSize;
+                         iX += 8, ++pabySrc, pabyDst += 8)
+                    {
+                        const int srcByte = *pabySrc;
+                        pabyDst[0] = (srcByte >> 7) & 1;
+                        pabyDst[1] = (srcByte >> 6) & 1;
+                        pabyDst[2] = (srcByte >> 5) & 1;
+                        pabyDst[3] = (srcByte >> 4) & 1;
+                        pabyDst[4] = (srcByte >> 3) & 1;
+                        pabyDst[5] = (srcByte >> 2) & 1;
+                        pabyDst[6] = (srcByte >> 1) & 1;
+                        pabyDst[7] = (srcByte >> 0) & 1;
+                    }
+                }
+                if (iX < nBlockXSize)
+                {
+                    for (; iX < nBlockXSize; ++iX, ++pabyDst)
+                    {
+                        *pabyDst = (*pabySrc & (0x80 >> (iX % 8))) ? val : 0;
+                    }
+                    ++pabySrc;
+                }
+            }
+
+            std::swap(abyDecompressedStrile, bufferForOneBitExpansion);
+        }
+        else if (m_image->compression() == LIBERTIFF_NS::Compression::None ||
+                 m_image->compression() == LIBERTIFF_NS::Compression::LZW ||
+                 m_decompressor)
+        {
+            if (m_image->readContext()->mustByteSwap() &&
+                m_image->predictor() != 3)
+            {
+                if (GDALDataTypeIsComplex(eNativeDT))
+                {
+                    GDALSwapWordsEx(abyDecompressedStrile.data(),
+                                    static_cast<int>(nNativeDTSize) / 2,
+                                    nActualPixelCount * nComponentsPerPixel * 2,
+                                    static_cast<int>(nNativeDTSize) / 2);
+                }
+                else
+                {
+                    GDALSwapWordsEx(abyDecompressedStrile.data(),
+                                    static_cast<int>(nNativeDTSize),
+                                    nActualPixelCount * nComponentsPerPixel,
+                                    static_cast<int>(nNativeDTSize));
+                }
+            }
+
+            if (m_image->predictor() == 2)
+            {
+                for (int iY = 0; iY < nBlockActualYSize; ++iY)
+                {
+                    auto ptr =
+                        abyDecompressedStrile.data() +
+                        nNativeDTSize * iY * nBlockXSize * nComponentsPerPixel;
+                    if (nNativeDTSize == sizeof(uint8_t))
+                    {
+                        HorizPredictorDecode<uint8_t>(ptr, nBlockXSize,
+                                                      nComponentsPerPixel);
+                    }
+                    else if (nNativeDTSize == sizeof(uint16_t))
+                    {
+                        HorizPredictorDecode<uint16_t>(ptr, nBlockXSize,
+                                                       nComponentsPerPixel);
+                    }
+                    else if (nNativeDTSize == sizeof(uint32_t))
+                    {
+                        HorizPredictorDecode<uint32_t>(ptr, nBlockXSize,
+                                                       nComponentsPerPixel);
+                    }
+                    else if (nNativeDTSize == sizeof(uint64_t))
+                    {
+                        HorizPredictorDecode<uint64_t>(ptr, nBlockXSize,
+                                                       nComponentsPerPixel);
+                    }
+                    else
+                    {
+                        CPLAssert(false);
+                    }
+                }
+            }
+            else if (m_image->predictor() == 3)
+            {
+                for (int iY = 0; iY < nBlockActualYSize; ++iY)
+                {
+                    auto ptr =
+                        abyDecompressedStrile.data() +
+                        nNativeDTSize * iY * nBlockXSize * nComponentsPerPixel;
+                    bool ok = true;
+                    if (nNativeDTSize == sizeof(uint32_t))
+                    {
+                        ok = FloatingPointHorizPredictorDecode<uint32_t>(
+                            tlsState
+                                .m_floatingPointHorizPredictorDecodeTmpBuffer,
+                            ptr, nBlockXSize, nComponentsPerPixel);
+                    }
+                    else if (nNativeDTSize == sizeof(uint64_t))
+                    {
+                        ok = FloatingPointHorizPredictorDecode<uint64_t>(
+                            tlsState
+                                .m_floatingPointHorizPredictorDecodeTmpBuffer,
+                            ptr, nBlockXSize, nComponentsPerPixel);
+                    }
+                    else
+                    {
+                        CPLAssert(false);
+                    }
+                    if (!ok)
+                        return false;
+                }
+            }
+        }
+    }
+
+    // Copy decompress strile into user buffer
+    if (pabyBlockData)
+    {
+        const auto IsContiguousBandMap = [nBandCount, panBandMap]()
+        {
+            for (int i = 0; i < nBandCount; ++i)
+            {
+                if (panBandMap[i] != i + 1)
+                    return false;
+            }
+            return true;
+        };
+
+        const int nBufTypeSize = GDALGetDataTypeSizeBytes(eBufType);
+        if (!bSeparate && nBands > 1 && nBands == nBandCount &&
+            nBufTypeSize == nPixelSpace && IsContiguousBandMap())
+        {
+            // Optimization: reading a pixel-interleaved buffer into a band-interleaved buffer
+            std::vector<void *> &apabyDest = tlsState.m_apabyDest;
+            apabyDest.resize(nBands);
+            for (int iBand = 0; iBand < nBandCount; ++iBand)
+            {
+                apabyDest[iBand] = pabyBlockData + iBand * nBandSpace;
+            }
+            for (int iY = 0; iY < nBlockActualYSize; ++iY)
+            {
+                if (iY > 0)
+                {
+                    for (int iBand = 0; iBand < nBandCount; ++iBand)
+                    {
+                        apabyDest[iBand] =
+                            static_cast<GByte *>(apabyDest[iBand]) + nLineSpace;
+                    }
+                }
+                GDALDeinterleave(abyDecompressedStrile.data() +
+                                     nNativeDTSize * iY * nBlockXSize * nBands,
+                                 eNativeDT, nBands, apabyDest.data(), eBufType,
+                                 nBlockActualXSize);
+            }
+        }
+        else if (!bSeparate && nBands == nBandCount &&
+                 nBufTypeSize == nBandSpace &&
+                 nPixelSpace == nBandSpace * nBandCount &&
+                 IsContiguousBandMap())
+        {
+            // Optimization reading a pixel-interleaved buffer into a pixel-interleaved buffer
+            for (int iY = 0; iY < nBlockActualYSize; ++iY)
+            {
+                GDALCopyWords64(
+                    abyDecompressedStrile.data() +
+                        nNativeDTSize * iY * nBlockXSize * nBands,
+                    eNativeDT, static_cast<int>(nNativeDTSize),
+                    pabyBlockData + iY * nLineSpace, eBufType, nBufTypeSize,
+                    static_cast<GPtrDiff_t>(
+                        static_cast<GIntBig>(nBlockActualXSize) * nBands));
+            }
+        }
+        else
+        {
+            // General case
+            const int nSrcPixels = bSeparate ? 1 : nBands;
+            for (int iBand = 0; iBand < nBandCount; ++iBand)
+            {
+                const int iSrcBand = bSeparate ? 0 : panBandMap[iBand] - 1;
+                for (int iY = 0; iY < nBlockActualYSize; ++iY)
+                {
+                    GDALCopyWords64(
+                        abyDecompressedStrile.data() +
+                            nNativeDTSize *
+                                (iY * nBlockXSize * nSrcPixels + iSrcBand),
+                        eNativeDT, static_cast<int>(nSrcPixels * nNativeDTSize),
+                        pabyBlockData + iBand * nBandSpace + iY * nLineSpace,
+                        eBufType, nBufTypeSize, nBlockActualXSize);
+                }
+            }
+        }
+    }
+
+    tlsState.m_curStrileIdx = curStrileIdx;
+    tlsState.m_curStrileMissing = false;
+
+    return true;
+}
+
+/************************************************************************/
+/*                            Identify()                                */
+/************************************************************************/
+
+/* static */ int LIBERTIFFDataset::Identify(GDALOpenInfo *poOpenInfo)
+{
+    return poOpenInfo->eAccess != GA_Update &&
+           (STARTS_WITH_CI(poOpenInfo->pszFilename, "GTIFF_DIR:") ||
+            (poOpenInfo->fpL && poOpenInfo->nHeaderBytes >= 8 &&
+             (((poOpenInfo->pabyHeader[0] == 'I' &&
+                poOpenInfo->pabyHeader[1] == 'I') &&
+               ((poOpenInfo->pabyHeader[2] == 0x2A &&
+                 poOpenInfo->pabyHeader[3] == 0) ||
+                (poOpenInfo->pabyHeader[2] == 0x2B &&
+                 poOpenInfo->pabyHeader[3] == 0))) ||
+              ((poOpenInfo->pabyHeader[0] == 'M' &&
+                poOpenInfo->pabyHeader[1] == 'M') &&
+               ((poOpenInfo->pabyHeader[2] == 0 &&
+                 poOpenInfo->pabyHeader[3] == 0x2A) ||
+                (poOpenInfo->pabyHeader[2] == 0 &&
+                 poOpenInfo->pabyHeader[3] == 0x2B))))));
+}
+
+/************************************************************************/
+/*                        ComputeGDALDataType()                         */
+/************************************************************************/
+
+GDALDataType LIBERTIFFDataset::ComputeGDALDataType() const
+{
+
+    GDALDataType eDT = GDT_Unknown;
+
+    switch (m_image->sampleFormat())
+    {
+        case LIBERTIFF_NS::SampleFormat::UnsignedInt:
+        {
+            if (m_image->bitsPerSample() == 1 &&
+                (m_image->samplesPerPixel() == 1 ||
+                 m_image->planarConfiguration() ==
+                     LIBERTIFF_NS::PlanarConfiguration::Separate))
+            {
+                eDT = GDT_Byte;
+            }
+            else if (m_image->bitsPerSample() == 8)
+                eDT = GDT_Byte;
+            else if (m_image->bitsPerSample() == 16)
+                eDT = GDT_UInt16;
+            else if (m_image->bitsPerSample() == 32)
+                eDT = GDT_UInt32;
+            else if (m_image->bitsPerSample() == 64)
+                eDT = GDT_UInt64;
+            break;
+        }
+
+        case LIBERTIFF_NS::SampleFormat::SignedInt:
+        {
+            if (m_image->bitsPerSample() == 8)
+                eDT = GDT_Int8;
+            else if (m_image->bitsPerSample() == 16)
+                eDT = GDT_Int16;
+            else if (m_image->bitsPerSample() == 32)
+                eDT = GDT_Int32;
+            else if (m_image->bitsPerSample() == 64)
+                eDT = GDT_Int64;
+            break;
+        }
+
+        case LIBERTIFF_NS::SampleFormat::IEEEFP:
+        {
+            if (m_image->bitsPerSample() == 32)
+                eDT = GDT_Float32;
+            else if (m_image->bitsPerSample() == 64)
+                eDT = GDT_Float64;
+            break;
+        }
+
+        case LIBERTIFF_NS::SampleFormat::ComplexInt:
+        {
+            if (m_image->bitsPerSample() == 32)
+                eDT = GDT_CInt16;
+            else if (m_image->bitsPerSample() == 64)
+                eDT = GDT_CInt32;
+            break;
+        }
+
+        case LIBERTIFF_NS::SampleFormat::ComplexIEEEFP:
+        {
+            if (m_image->bitsPerSample() == 64)
+                eDT = GDT_CFloat32;
+            else if (m_image->bitsPerSample() == 128)
+                eDT = GDT_CFloat64;
+            break;
+        }
+
+        default:
+            break;
+    }
+
+    if (m_image->bitsPerSample() == 12 &&
+        m_image->compression() == LIBERTIFF_NS::Compression::JPEG)
+    {
+        auto poJPEGDrv = GetGDALDriverManager()->GetDriverByName("JPEG");
+        if (poJPEGDrv)
+        {
+            const char *pszJPEGDataTypes =
+                poJPEGDrv->GetMetadataItem(GDAL_DMD_CREATIONDATATYPES);
+            if (pszJPEGDataTypes && strstr(pszJPEGDataTypes, "UInt16"))
+                eDT = GDT_UInt16;
+        }
+    }
+
+    return eDT;
+}
+
+/************************************************************************/
+/*                       ProcessCompressionMethod()                     */
+/************************************************************************/
+
+bool LIBERTIFFDataset::ProcessCompressionMethod()
+{
+    if (m_image->compression() == LIBERTIFF_NS::Compression::PackBits)
+    {
+        GDALDataset::SetMetadataItem("COMPRESSION", "PACKBITS",
+                                     "IMAGE_STRUCTURE");
+    }
+    else if (m_image->compression() == LIBERTIFF_NS::Compression::Deflate ||
+             m_image->compression() == LIBERTIFF_NS::Compression::LegacyDeflate)
+    {
+        m_decompressor = CPLGetDecompressor("zlib");
+        GDALDataset::SetMetadataItem("COMPRESSION", "DEFLATE",
+                                     "IMAGE_STRUCTURE");
+    }
+    else if (m_image->compression() == LIBERTIFF_NS::Compression::ZSTD)
+    {
+        m_decompressor = CPLGetDecompressor("zstd");
+        if (!m_decompressor)
+        {
+            ReportError(CE_Failure, CPLE_NotSupported,
+                        "Compression = ZSTD unhandled because GDAL "
+                        "has not been built against libzstd");
+            return false;
+        }
+        GDALDataset::SetMetadataItem("COMPRESSION", "ZSTD", "IMAGE_STRUCTURE");
+    }
+    else if (m_image->compression() == LIBERTIFF_NS::Compression::LZMA)
+    {
+        m_decompressor = CPLGetDecompressor("lzma");
+        if (!m_decompressor)
+        {
+            ReportError(CE_Failure, CPLE_NotSupported,
+                        "Compression = LZMA unhandled because GDAL "
+                        "has not been built against liblzma");
+            return false;
+        }
+        GDALDataset::SetMetadataItem("COMPRESSION", "LZMA", "IMAGE_STRUCTURE");
+    }
+    else if (m_image->compression() == LIBERTIFF_NS::Compression::LZW)
+    {
+        GDALDataset::SetMetadataItem("COMPRESSION", "LZW", "IMAGE_STRUCTURE");
+    }
+    else if (m_image->compression() == LIBERTIFF_NS::Compression::JPEG)
+    {
+        if (!GDALGetDriverByName("JPEG"))
+        {
+            ReportError(
+                CE_Failure, CPLE_NotSupported,
+                "Compression = JPEG not supported because JPEG driver missing");
+            return false;
+        }
+        if (m_image->photometricInterpretation() ==
+                LIBERTIFF_NS::PhotometricInterpretation::YCbCr &&
+            m_image->samplesPerPixel() == 3)
+        {
+            GDALDataset::SetMetadataItem("SOURCE_COLOR_SPACE", "YCbCr",
+                                         "IMAGE_STRUCTURE");
+            GDALDataset::SetMetadataItem("COMPRESSION", "YCbCr JPEG",
+                                         "IMAGE_STRUCTURE");
+        }
+        else
+        {
+            GDALDataset::SetMetadataItem("COMPRESSION", "JPEG",
+                                         "IMAGE_STRUCTURE");
+        }
+        if (m_image->samplesPerPixel() != 1 &&
+            m_image->samplesPerPixel() != 3 &&
+            m_image->samplesPerPixel() != 4 &&
+            m_image->planarConfiguration() ==
+                LIBERTIFF_NS::PlanarConfiguration::Contiguous)
+        {
+            ReportError(CE_Failure, CPLE_NotSupported,
+                        "Compression = JPEG not supported when samplesPerPixel "
+                        "!= 1, 3 or 4 and planarConfiguration = Contiguous");
+            return false;
+        }
+
+        const auto psJPEGTablesTag =
+            m_image->tag(LIBERTIFF_NS::TagCode::JPEGTables);
+        if (psJPEGTablesTag &&
+            psJPEGTablesTag->type == LIBERTIFF_NS::TagType::Undefined &&
+            psJPEGTablesTag->count > 4 &&
+            !psJPEGTablesTag->invalid_value_offset &&
+            psJPEGTablesTag->count < 65536)
+        {
+            bool ok = true;
+            m_jpegTablesOri =
+                m_image->readTagAsVector<uint8_t>(*psJPEGTablesTag, ok);
+            if (m_jpegTablesOri.size() >= 4 && m_jpegTablesOri[0] == 0xff &&
+                m_jpegTablesOri[1] == 0xd8 &&
+                m_jpegTablesOri[m_jpegTablesOri.size() - 2] == 0xff &&
+                m_jpegTablesOri.back() == 0xd9)
+            {
+                m_jpegTables.insert(
+                    m_jpegTables.end(), m_jpegTablesOri.data() + 2,
+                    m_jpegTablesOri.data() + m_jpegTablesOri.size() - 2);
+            }
+        }
+
+        if (m_image->samplesPerPixel() == 4 &&
+            m_image->planarConfiguration() ==
+                LIBERTIFF_NS::PlanarConfiguration::Contiguous)
+        {
+            const GByte abyAdobeAPP14RGB[] = {
+                0xFF, 0xEE, 0x00, 0x0E, 0x41, 0x64, 0x6F, 0x62,
+                0x65, 0x00, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00};
+            m_jpegTables.insert(m_jpegTables.end(), abyAdobeAPP14RGB,
+                                abyAdobeAPP14RGB + sizeof(abyAdobeAPP14RGB));
+        }
+    }
+    else if (m_image->compression() == LIBERTIFF_NS::Compression::WEBP)
+    {
+        if (!GDALGetDriverByName("WEBP"))
+        {
+            ReportError(
+                CE_Failure, CPLE_NotSupported,
+                "Compression = WEBP not supported because WEBP driver missing");
+            return false;
+        }
+        GDALDataset::SetMetadataItem("COMPRESSION", "WEBP", "IMAGE_STRUCTURE");
+    }
+    else if (m_image->compression() == LIBERTIFF_NS::Compression::JXL ||
+             m_image->compression() == LIBERTIFF_NS::Compression::JXL_DNG_1_7)
+    {
+        if (!GDALGetDriverByName("JPEGXL"))
+        {
+            ReportError(
+                CE_Failure, CPLE_NotSupported,
+                "Compression = JXL not supported because JXL driver missing");
+            return false;
+        }
+        GDALDataset::SetMetadataItem("COMPRESSION", "JXL", "IMAGE_STRUCTURE");
+    }
+    else if (m_image->compression() == LIBERTIFF_NS::Compression::LERC)
+    {
+#ifndef LERC_SUPPORT
+        ReportError(CE_Failure, CPLE_NotSupported,
+                    "Compression = LERC not supported because GDAL "
+                    "has not been built against liblerc");
+        return false;
+#else
+        const auto *psLercParametersTag =
+            m_image->tag(LIBERTIFF_NS::TagCode::LERCParameters);
+        if (psLercParametersTag &&
+            psLercParametersTag->type == LIBERTIFF_NS::TagType::Long &&
+            psLercParametersTag->count == 2)
+        {
+            bool ok = true;
+            const auto lercParameters =
+                m_image->readTagAsVector<uint32_t>(*psLercParametersTag, ok);
+            if (!ok || lercParameters.size() != 2)
+            {
+                ReportError(CE_Failure, CPLE_NotSupported,
+                            "Tag LERCParameters is invalid");
+                return false;
+            }
+            m_lercVersion = lercParameters[0];
+            m_lercAdditionalCompression = lercParameters[1];
+#ifndef ZSTD_SUPPORT
+            if (m_lercAdditionalCompression == LERC_ADD_COMPRESSION_ZSTD)
+            {
+                ReportError(
+                    CE_Failure, CPLE_NotSupported,
+                    "Compression = LERC_ZSTD not supported because GDAL "
+                    "has not been built against libzstd");
+                return false;
+            }
+#endif
+        }
+
+        GDALDataset::SetMetadataItem(
+            "COMPRESSION",
+            m_lercAdditionalCompression == LERC_ADD_COMPRESSION_DEFLATE
+                ? "LERC_DEFLATE"
+            : m_lercAdditionalCompression == LERC_ADD_COMPRESSION_ZSTD
+                ? "LERC_ZSTD"
+                : "LERC",
+            "IMAGE_STRUCTURE");
+
+        if (m_lercVersion == LERC_VERSION_2_4)
+        {
+            GDALDataset::SetMetadataItem("LERC_VERSION", "2.4",
+                                         "IMAGE_STRUCTURE");
+        }
+#endif
+    }
+    else if (m_image->compression() != LIBERTIFF_NS::Compression::None)
+    {
+        CPLDebug("LIBERTIFF", "Compression = %s unhandled",
+                 LIBERTIFF_NS::compressionName(m_image->compression()));
+        return false;
+    }
+
+    return true;
+}
+
+/************************************************************************/
+/*                               Open()                                 */
+/************************************************************************/
+
+bool LIBERTIFFDataset::Open(std::unique_ptr<const LIBERTIFF_NS::Image> image)
+{
+    m_image = std::move(image);
+
+    // Basic sanity checks
+    if (m_image->width() == 0 ||
+        m_image->width() > static_cast<uint32_t>(INT_MAX) ||
+        m_image->height() == 0 ||
+        m_image->height() > static_cast<uint32_t>(INT_MAX) ||
+        m_image->samplesPerPixel() == 0 ||
+        m_image->samplesPerPixel() > static_cast<uint32_t>(INT_MAX))
+    {
+        CPLDebug("LIBERTIFF", "Invalid width, height, or samplesPerPixel");
+        return false;
+    }
+
+    nRasterXSize = static_cast<int>(m_image->width());
+    nRasterYSize = static_cast<int>(m_image->height());
+    const int l_nBands = static_cast<int>(m_image->samplesPerPixel());
+    if (!GDALCheckBandCount(l_nBands, false))
+        return false;
+
+    if (!ProcessCompressionMethod())
+        return false;
+
+    // Compute block size
+    int nBlockXSize;
+    int nBlockYSize;
+    if (m_image->isTiled())
+    {
+        if (m_image->tileWidth() == 0 ||
+            m_image->tileWidth() > static_cast<uint32_t>(INT_MAX) ||
+            m_image->tileHeight() == 0 ||
+            m_image->tileHeight() > static_cast<uint32_t>(INT_MAX))
+        {
+            CPLDebug("LIBERTIFF", "Invalid tileWidth or tileHeight");
+            return false;
+        }
+        nBlockXSize = static_cast<int>(m_image->tileWidth());
+        nBlockYSize = static_cast<int>(m_image->tileHeight());
+    }
+    else
+    {
+        if (m_image->rowsPerStripSanitized() == 0)
+        {
+            CPLDebug("LIBERTIFF", "Invalid rowsPerStrip");
+            return false;
+        }
+        nBlockXSize = nRasterXSize;
+        nBlockYSize = static_cast<int>(m_image->rowsPerStripSanitized());
+    }
+
+    const GDALDataType eDT = ComputeGDALDataType();
+
+    // Deal with Predictor tag
+    if (m_image->predictor() == 2)
+    {
+        GDALDataset::SetMetadataItem("PREDICTOR", "2", "IMAGE_STRUCTURE");
+    }
+    else if (m_image->predictor() == 3)
+    {
+        if (eDT != GDT_Float32 && eDT != GDT_Float64)
+        {
+            CPLDebug("LIBERTIFF", "Unhandled predictor=3 with non-float data");
+            return false;
+        }
+        GDALDataset::SetMetadataItem("PREDICTOR", "3", "IMAGE_STRUCTURE");
+    }
+    else if (m_image->predictor() > 3)
+    {
+        CPLDebug("LIBERTIFF", "Predictor = %u unhandled", m_image->predictor());
+        return false;
+    }
+
+    // Deal with PlanarConfiguration tag
+    if (m_image->planarConfiguration() ==
+            LIBERTIFF_NS::PlanarConfiguration::Separate ||
+        m_image->samplesPerPixel() == 1)
+        GDALDataset::SetMetadataItem("INTERLEAVE", "BAND", "IMAGE_STRUCTURE");
+    else
+        GDALDataset::SetMetadataItem("INTERLEAVE", "PIXEL", "IMAGE_STRUCTURE");
+
+    const int nNativeDTSize = GDALGetDataTypeSizeBytes(eDT);
+    const bool bSeparate = m_image->planarConfiguration() ==
+                           LIBERTIFF_NS::PlanarConfiguration::Separate;
+    // Sanity check that a strile can its on SIZE_MAX, to avoid further
+    // issues in ReadBlock()
+    if (static_cast<uint64_t>(nNativeDTSize) * (bSeparate ? 1 : l_nBands) >
+        std::numeric_limits<size_t>::max() /
+            (static_cast<uint64_t>(nBlockXSize) * nBlockYSize))
+    {
+        CPLDebug("LIBERTIFF", "Too large block");
+        return false;
+    }
+
+    // Process GDAL_NODATA tag
+    bool bHasNoData = false;
+    double dfNoData = 0;
+    const auto *tagNoData = m_image->tag(LIBERTIFF_NS::TagCode::GDAL_NODATA);
+    if (tagNoData && tagNoData->type == LIBERTIFF_NS::TagType::ASCII &&
+        !(tagNoData->count > 4 && tagNoData->invalid_value_offset) &&
+        tagNoData->count < 256)
+    {
+        bool ok = true;
+        const std::string noData = m_image->readTagAsString(*tagNoData, ok);
+        if (ok && !noData.empty())
+        {
+            bHasNoData = true;
+            dfNoData = CPLAtof(noData.c_str());
+        }
+    }
+
+    // Process ExtraSamples tag
+    int nRegularChannels = 0;
+    if (m_image->photometricInterpretation() ==
+        LIBERTIFF_NS::PhotometricInterpretation::MinIsBlack)
+    {
+        nRegularChannels = 1;
+    }
+    else if (m_image->photometricInterpretation() ==
+             LIBERTIFF_NS::PhotometricInterpretation::RGB)
+    {
+        nRegularChannels = 3;
+    }
+    const auto *psExtraSamplesTag =
+        m_image->tag(LIBERTIFF_NS::TagCode::ExtraSamples);
+    if (nRegularChannels > 0 && l_nBands > nRegularChannels &&
+        psExtraSamplesTag &&
+        psExtraSamplesTag->type == LIBERTIFF_NS::TagType::Short &&
+        psExtraSamplesTag->count ==
+            static_cast<unsigned>(l_nBands - nRegularChannels))
+    {
+        bool ok = true;
+        m_extraSamples =
+            m_image->readTagAsVector<uint16_t>(*psExtraSamplesTag, ok);
+    }
+
+    // Preload TileOffsets and TileByteCounts if not too big
+    if (m_image->isTiled())
+    {
+        const auto *psTileOffsets =
+            m_image->tag(LIBERTIFF_NS::TagCode::TileOffsets);
+        const auto *psTileByteCounts =
+            m_image->tag(LIBERTIFF_NS::TagCode::TileByteCounts);
+        if (psTileOffsets &&
+            (psTileOffsets->type == LIBERTIFF_NS::TagType::Long ||
+             psTileOffsets->type == LIBERTIFF_NS::TagType::Long8) &&
+            !psTileOffsets->invalid_value_offset &&
+            psTileOffsets->count <= 4096 && psTileByteCounts &&
+            psTileByteCounts->type == LIBERTIFF_NS::TagType::Long &&
+            !psTileByteCounts->invalid_value_offset &&
+            psTileByteCounts->count <= 4096)
+        {
+            bool ok = true;
+            if (psTileOffsets->type == LIBERTIFF_NS::TagType::Long)
+                m_tileOffsets =
+                    m_image->readTagAsVector<uint32_t>(*psTileOffsets, ok);
+            else
+                m_tileOffsets64 =
+                    m_image->readTagAsVector<uint64_t>(*psTileOffsets, ok);
+            m_tileByteCounts =
+                m_image->readTagAsVector<uint32_t>(*psTileByteCounts, ok);
+            if (!ok)
+            {
+                m_tileOffsets.clear();
+                m_tileOffsets64.clear();
+                m_tileByteCounts.clear();
+            }
+        }
+    }
+
+    // Create raster bands
+    for (int i = 0; i < l_nBands; ++i)
+    {
+        auto poBand = std::make_unique<LIBERTIFFBand>(this, i + 1, eDT,
+                                                      nBlockXSize, nBlockYSize);
+        poBand->m_bHasNoData = bHasNoData;
+        poBand->m_dfNoData = dfNoData;
+        if (m_image->photometricInterpretation() ==
+            LIBERTIFF_NS::PhotometricInterpretation::MinIsBlack)
+        {
+            if (i == 0)
+                poBand->m_eColorInterp = GCI_GrayIndex;
+        }
+        else if (m_image->photometricInterpretation() ==
+                     LIBERTIFF_NS::PhotometricInterpretation::RGB ||
+                 (m_image->photometricInterpretation() ==
+                      LIBERTIFF_NS::PhotometricInterpretation::YCbCr &&
+                  m_image->samplesPerPixel() == 3))
+        {
+            if (i < 3)
+                poBand->m_eColorInterp =
+                    static_cast<GDALColorInterp>(GCI_RedBand + i);
+        }
+        if (i >= nRegularChannels && !m_extraSamples.empty())
+        {
+            if (m_extraSamples[i - nRegularChannels] ==
+                LIBERTIFF_NS::ExtraSamples::UnAssociatedAlpha)
+            {
+                poBand->m_eColorInterp = GCI_AlphaBand;
+                if (!m_poAlphaBand)
+                    m_poAlphaBand = poBand.get();
+            }
+            else if (m_extraSamples[i - nRegularChannels] ==
+                     LIBERTIFF_NS::ExtraSamples::AssociatedAlpha)
+            {
+                poBand->m_eColorInterp = GCI_AlphaBand;
+                poBand->GDALRasterBand::SetMetadataItem(
+                    "ALPHA", "PREMULTIPLIED", "IMAGE_STRUCTURE");
+                if (!m_poAlphaBand)
+                    m_poAlphaBand = poBand.get();
+            }
+        }
+
+        if (m_image->bitsPerSample() != 8 && m_image->bitsPerSample() != 16 &&
+            m_image->bitsPerSample() != 32 && m_image->bitsPerSample() != 64 &&
+            m_image->bitsPerSample() != 128)
+        {
+            poBand->GDALRasterBand::SetMetadataItem(
+                "NBITS", CPLSPrintf("%u", m_image->bitsPerSample()),
+                "IMAGE_STRUCTURE");
+        }
+
+        if (l_nBands == 1 && eDT == GDT_Byte)
+        {
+            poBand->ReadColorMap();
+        }
+
+        if (m_image->photometricInterpretation() ==
+            LIBERTIFF_NS::PhotometricInterpretation::MinIsWhite)
+        {
+            GDALDataset::SetMetadataItem("MINISWHITE", "YES",
+                                         "IMAGE_STRUCTURE");
+        }
+
+        if (m_image->bitsPerSample() == 1 && !poBand->m_poColorTable)
+        {
+            poBand->m_poColorTable = std::make_unique<GDALColorTable>();
+            const GDALColorEntry oEntryBlack = {0, 0, 0, 255};
+            const GDALColorEntry oEntryWhite = {255, 255, 255, 255};
+            if (m_image->photometricInterpretation() ==
+                LIBERTIFF_NS::PhotometricInterpretation::MinIsWhite)
+            {
+                poBand->m_poColorTable->SetColorEntry(0, &oEntryWhite);
+                poBand->m_poColorTable->SetColorEntry(1, &oEntryBlack);
+            }
+            else
+            {
+                poBand->m_poColorTable->SetColorEntry(0, &oEntryBlack);
+                poBand->m_poColorTable->SetColorEntry(1, &oEntryWhite);
+            }
+            poBand->m_eColorInterp = GCI_PaletteIndex;
+        }
+
+        SetBand(i + 1, std::move(poBand));
+    }
+
+    nOpenFlags = GDAL_OF_RASTER | GDAL_OF_THREAD_SAFE;
+
+    return true;
+}
+
+/************************************************************************/
+/*                               Open()                                 */
+/************************************************************************/
+
+bool LIBERTIFFDataset::Open(GDALOpenInfo *poOpenInfo)
+{
+    SetDescription(poOpenInfo->pszFilename);
+
+    int iSelectedSubDS = -1;
+    if (STARTS_WITH_CI(poOpenInfo->pszFilename, "GTIFF_DIR:"))
+    {
+        iSelectedSubDS = atoi(poOpenInfo->pszFilename + strlen("GTIFF_DIR:"));
+        if (iSelectedSubDS <= 0)
+        {
+            CPLError(CE_Failure, CPLE_AppDefined, "Invalid subdataset syntax");
+            return false;
+        }
+        const char *pszNextColon =
+            strchr(poOpenInfo->pszFilename + strlen("GTIFF_DIR:"), ':');
+        if (!pszNextColon)
+        {
+            CPLError(CE_Failure, CPLE_AppDefined, "Invalid subdataset syntax");
+            return false;
+        }
+        m_poFile.reset(VSIFOpenL(pszNextColon + 1, "rb"));
+        if (!m_poFile)
+        {
+            CPLError(CE_Failure, CPLE_FileIO, "Cannot open %s",
+                     pszNextColon + 1);
+            return false;
+        }
+        m_fileReader =
+            std::make_shared<const LIBERTIFFDatasetFileReader>(m_poFile.get());
+    }
+    else
+    {
+        m_fileReader =
+            std::make_shared<const LIBERTIFFDatasetFileReader>(poOpenInfo->fpL);
+    }
+
+    auto mainImage = LIBERTIFF_NS::open(m_fileReader);
+    if (!mainImage)
+    {
+        CPLError(CE_Failure, CPLE_AppDefined, "Cannot open TIFF image");
+        return false;
+    }
+
+    if (mainImage->subFileType() != LIBERTIFF_NS::SubFileTypeFlags::Page &&
+        mainImage->subFileType() != 0)
+    {
+        CPLDebug("LIBERTIFF", "Invalid subFileType value for first image");
+        return false;
+    }
+
+    // Check structural metadata (for COG)
+    const int nOffsetOfStructuralMetadata =
+        poOpenInfo->nHeaderBytes && ((poOpenInfo->pabyHeader[2] == 0x2B ||
+                                      poOpenInfo->pabyHeader[3] == 0x2B))
+            ? 16
+            : 8;
+    if (poOpenInfo->nHeaderBytes >
+            nOffsetOfStructuralMetadata +
+                static_cast<int>(strlen("GDAL_STRUCTURAL_METADATA_SIZE=")) &&
+        memcmp(poOpenInfo->pabyHeader + nOffsetOfStructuralMetadata,
+               "GDAL_STRUCTURAL_METADATA_SIZE=",
+               strlen("GDAL_STRUCTURAL_METADATA_SIZE=")) == 0)
+    {
+        const char *pszStructuralMD = reinterpret_cast<const char *>(
+            poOpenInfo->pabyHeader + nOffsetOfStructuralMetadata);
+        const bool bLayoutIFDSBeforeData =
+            strstr(pszStructuralMD, "LAYOUT=IFDS_BEFORE_DATA") != nullptr;
+        const bool bBlockOrderRowMajor =
+            strstr(pszStructuralMD, "BLOCK_ORDER=ROW_MAJOR") != nullptr;
+        const bool bLeaderSizeAsUInt4 =
+            strstr(pszStructuralMD, "BLOCK_LEADER=SIZE_AS_UINT4") != nullptr;
+        const bool bTrailerRepeatedLast4BytesRepeated =
+            strstr(pszStructuralMD, "BLOCK_TRAILER=LAST_4_BYTES_REPEATED") !=
+            nullptr;
+        const bool bKnownIncompatibleEdition =
+            strstr(pszStructuralMD, "KNOWN_INCOMPATIBLE_EDITION=YES") !=
+            nullptr;
+        if (bKnownIncompatibleEdition)
+        {
+            ReportError(CE_Warning, CPLE_AppDefined,
+                        "This file used to have optimizations in its layout, "
+                        "but those have been, at least partly, invalidated by "
+                        "later changes");
+        }
+        else if (bLayoutIFDSBeforeData && bBlockOrderRowMajor &&
+                 bLeaderSizeAsUInt4 && bTrailerRepeatedLast4BytesRepeated)
+        {
+            GDALDataset::SetMetadataItem("LAYOUT", "COG", "IMAGE_STRUCTURE");
+        }
+    }
+
+    if (!Open(std::move(mainImage)))
+        return false;
+
+    // Iterate over overviews
+    LIBERTIFFDataset *poLastNonMaskDS = this;
+    auto imageNext = m_image->next();
+    if (imageNext &&
+        (m_image->subFileType() == 0 ||
+         m_image->subFileType() == LIBERTIFF_NS::SubFileTypeFlags::Page) &&
+        (imageNext->subFileType() == 0 ||
+         imageNext->subFileType() == LIBERTIFF_NS::SubFileTypeFlags::Page))
+    {
+        int iSubDS = 1;
+        CPLStringList aosList;
+        auto curImage = std::move(m_image);
+        do
+        {
+            if (iSelectedSubDS > 0 && iSubDS == iSelectedSubDS)
+            {
+                m_image = std::move(curImage);
+                break;
+            }
+            if (iSelectedSubDS < 0)
+            {
+                aosList.AddNameValue(
+                    CPLSPrintf("SUBDATASET_%d_NAME", iSubDS),
+                    CPLSPrintf("GTIFF_DIR:%d:%s", iSubDS, GetDescription()));
+                aosList.AddNameValue(CPLSPrintf("SUBDATASET_%d_DESC", iSubDS),
+                                     CPLSPrintf("Page %d (%uP x %uL x %uB)",
+                                                iSubDS, curImage->width(),
+                                                curImage->height(),
+                                                curImage->samplesPerPixel()));
+            }
+            ++iSubDS;
+            if (iSubDS == 65536)
+            {
+                ReportError(CE_Warning, CPLE_AppDefined,
+                            "Stopping IFD scanning at 65536th one");
+                break;
+            }
+            curImage = curImage->next();
+        } while (curImage);
+        if (iSelectedSubDS < 0)
+        {
+            for (int i = 0; i < nBands; ++i)
+                delete papoBands[i];
+            CPLFree(papoBands);
+            papoBands = nullptr;
+            nRasterXSize = 0;
+            nRasterYSize = 0;
+            GDALDataset::SetMetadata(aosList.List(), "SUBDATASETS");
+            return true;
+        }
+        else if (!m_image)
+        {
+            CPLError(CE_Failure, CPLE_AppDefined, "Cannot open %dth image",
+                     iSelectedSubDS);
+            return false;
+        }
+    }
+    else if (iSelectedSubDS < 0)
+    {
+        auto curImage = std::move(imageNext);
+        int iters = 0;
+        while (curImage)
+        {
+            auto nextImage = curImage->next();
+            if (curImage->subFileType() ==
+                LIBERTIFF_NS::SubFileTypeFlags::ReducedImage)
+            {
+                // Overview IFD
+                auto poOvrDS = std::make_unique<LIBERTIFFDataset>();
+                if (poOvrDS->Open(std::move(curImage)) &&
+                    poOvrDS->GetRasterCount() == nBands &&
+                    poOvrDS->GetRasterXSize() <= nRasterXSize &&
+                    poOvrDS->GetRasterYSize() <= nRasterYSize &&
+                    poOvrDS->GetRasterBand(1)->GetRasterDataType() ==
+                        GetRasterBand(1)->GetRasterDataType())
+                {
+                    m_apoOvrDSOwned.push_back(std::move(poOvrDS));
+                    auto poOvrDSRaw = m_apoOvrDSOwned.back().get();
+                    m_apoOvrDS.push_back(poOvrDSRaw);
+                    poLastNonMaskDS = poOvrDSRaw;
+                }
+            }
+            else if ((curImage->subFileType() &
+                      LIBERTIFF_NS::SubFileTypeFlags::Mask) != 0)
+            {
+                // Mask IFD
+                if (!poLastNonMaskDS->m_poMaskDS)
+                {
+                    auto poMaskDS = std::make_unique<LIBERTIFFDataset>();
+                    if (poMaskDS->Open(std::move(curImage)) &&
+                        poMaskDS->GetRasterCount() == 1 &&
+                        poMaskDS->GetRasterXSize() ==
+                            poLastNonMaskDS->nRasterXSize &&
+                        poMaskDS->GetRasterYSize() ==
+                            poLastNonMaskDS->nRasterYSize &&
+                        poMaskDS->GetRasterBand(1)->GetRasterDataType() ==
+                            GDT_Byte)
+                    {
+                        poMaskDS->m_bExpand1To255 = true;
+                        poLastNonMaskDS->m_poMaskDS = std::move(poMaskDS);
+                        if (poLastNonMaskDS != this && m_poMaskDS)
+                        {
+                            // Also register the mask as the overview of the main
+                            // mask
+                            m_poMaskDS->m_apoOvrDS.push_back(
+                                poLastNonMaskDS->m_poMaskDS.get());
+                        }
+                    }
+                }
+            }
+            else
+            {
+                CPLDebug("LIBERTIFF",
+                         "Unhandled subFileType value for auxiliary image");
+                return false;
+            }
+            curImage = std::move(nextImage);
+
+            ++iters;
+            if (iters == 64)
+            {
+                ReportError(CE_Warning, CPLE_AppDefined,
+                            "Stopping IFD scanning at 64th one");
+                break;
+            }
+        }
+    }
+
+    static const struct
+    {
+        LIBERTIFF_NS::TagCodeType code;
+        const char *mditem;
+    } strTags[] = {
+        {LIBERTIFF_NS::TagCode::DocumentName, "TIFFTAG_DOCUMENTNAME"},
+        {LIBERTIFF_NS::TagCode::ImageDescription, "TIFFTAG_IMAGEDESCRIPTION"},
+        {LIBERTIFF_NS::TagCode::Software, "TIFFTAG_SOFTWARE"},
+        {LIBERTIFF_NS::TagCode::DateTime, "TIFFTAG_DATETIME"},
+        {LIBERTIFF_NS::TagCode::Copyright, "TIFFTAG_COPYRIGHT"},
+    };
+
+    for (const auto &strTag : strTags)
+    {
+        const auto *tag = m_image->tag(strTag.code);
+        constexpr size_t ARBITRARY_MAX_SIZE = 65536;
+        if (tag && tag->type == LIBERTIFF_NS::TagType::ASCII &&
+            !(tag->count > 4 && tag->invalid_value_offset) &&
+            tag->count < ARBITRARY_MAX_SIZE)
+        {
+            bool ok = true;
+            const std::string str = m_image->readTagAsString(*tag, ok);
+            if (ok)
+            {
+                GDALDataset::SetMetadataItem(strTag.mditem, str.c_str());
+            }
+        }
+    }
+
+    ReadSRS();
+    ReadGeoTransform();
+    ReadRPCTag();
+
+    const auto *psGDALMetadataTag =
+        m_image->tag(LIBERTIFF_NS::TagCode::GDAL_METADATA);
+    constexpr size_t ARBITRARY_MAX_SIZE_GDAL_METADATA = 10 * 1024 * 1024;
+    if (psGDALMetadataTag &&
+        psGDALMetadataTag->type == LIBERTIFF_NS::TagType::ASCII &&
+        !(psGDALMetadataTag->count > 4 &&
+          psGDALMetadataTag->invalid_value_offset) &&
+        psGDALMetadataTag->count < ARBITRARY_MAX_SIZE_GDAL_METADATA)
+    {
+        bool ok = true;
+        const std::string str =
+            m_image->readTagAsString(*psGDALMetadataTag, ok);
+        if (ok)
+        {
+            auto oRoot = CPLXMLTreeCloser(CPLParseXMLString(str.c_str()));
+            if (oRoot.get())
+            {
+                const CPLXMLNode *psItem =
+                    oRoot.get() ? CPLGetXMLNode(oRoot.get(), "=GDALMetadata")
+                                : nullptr;
+                if (psItem)
+                    psItem = psItem->psChild;
+                for (; psItem != nullptr; psItem = psItem->psNext)
+                {
+                    if (psItem->eType != CXT_Element ||
+                        !EQUAL(psItem->pszValue, "Item"))
+                        continue;
+
+                    const char *pszKey =
+                        CPLGetXMLValue(psItem, "name", nullptr);
+                    const char *pszValue =
+                        CPLGetXMLValue(psItem, nullptr, nullptr);
+                    int nBand = atoi(CPLGetXMLValue(psItem, "sample", "-1"));
+                    if (nBand < -1 || nBand > 65535)
+                        continue;
+                    nBand++;
+                    const char *pszRole = CPLGetXMLValue(psItem, "role", "");
+                    const char *pszDomain =
+                        CPLGetXMLValue(psItem, "domain", "");
+
+                    if (pszKey == nullptr || pszValue == nullptr)
+                        continue;
+                    if (EQUAL(pszDomain, "IMAGE_STRUCTURE"))
+                    {
+                        if (m_image->compression() ==
+                                LIBERTIFF_NS::Compression::WEBP &&
+                            EQUAL(pszKey, "COMPRESSION_REVERSIBILITY"))
+                        {
+                            // go on
+                        }
+                        else if (m_image->compression() ==
+                                     LIBERTIFF_NS::Compression::WEBP &&
+                                 EQUAL(pszKey, "WEBP_LEVEL"))
+                        {
+                            const int nLevel = atoi(pszValue);
+                            if (nLevel >= 1 && nLevel <= 100)
+                            {
+                                GDALDataset::SetMetadataItem(
+                                    "COMPRESSION_REVERSIBILITY", "LOSSY",
+                                    "IMAGE_STRUCTURE");
+                            }
+                        }
+                        else if (m_image->compression() ==
+                                     LIBERTIFF_NS::Compression::LERC &&
+                                 EQUAL(pszKey, "MAX_Z_ERROR"))
+                        {
+                            // go on
+                        }
+                        else if (m_image->compression() ==
+                                     LIBERTIFF_NS::Compression::LERC &&
+                                 EQUAL(pszKey, "MAX_Z_ERROR_OVERVIEW"))
+                        {
+                            // go on
+                        }
+                        else if (m_image->compression() ==
+                                     LIBERTIFF_NS::Compression::JXL &&
+                                 EQUAL(pszKey, "COMPRESSION_REVERSIBILITY"))
+                        {
+                            // go on
+                        }
+                        else if (m_image->compression() ==
+                                     LIBERTIFF_NS::Compression::JXL &&
+                                 EQUAL(pszKey, "JXL_DISTANCE"))
+                        {
+                            const double dfVal = CPLAtof(pszValue);
+                            if (dfVal > 0 && dfVal <= 15)
+                            {
+                                GDALDataset::SetMetadataItem(
+                                    "COMPRESSION_REVERSIBILITY", "LOSSY",
+                                    "IMAGE_STRUCTURE");
+                            }
+                        }
+                        else if (m_image->compression() ==
+                                     LIBERTIFF_NS::Compression::JXL &&
+                                 EQUAL(pszKey, "JXL_ALPHA_DISTANCE"))
+                        {
+                            const double dfVal = CPLAtof(pszValue);
+                            if (dfVal > 0 && dfVal <= 15)
+                            {
+                                GDALDataset::SetMetadataItem(
+                                    "COMPRESSION_REVERSIBILITY", "LOSSY",
+                                    "IMAGE_STRUCTURE");
+                            }
+                        }
+                        else if (m_image->compression() ==
+                                     LIBERTIFF_NS::Compression::JXL &&
+                                 EQUAL(pszKey, "JXL_EFFORT"))
+                        {
+                            // go on
+                        }
+                        else
+                        {
+                            continue;
+                        }
+                    }
+
+                    bool bIsXML = false;
+
+                    if (STARTS_WITH_CI(pszDomain, "xml:"))
+                        bIsXML = TRUE;
+
+                    // Note: this un-escaping should not normally be done, as the
+                    // deserialization of the tree from XML also does it, so we end up
+                    // width double XML escaping, but keep it for backward
+                    // compatibility.
+                    char *pszUnescapedValue =
+                        CPLUnescapeString(pszValue, nullptr, CPLES_XML);
+                    if (nBand == 0)
+                    {
+                        if (bIsXML)
+                        {
+                            char *apszMD[2] = {pszUnescapedValue, nullptr};
+                            GDALDataset::SetMetadata(apszMD, pszDomain);
+                        }
+                        else
+                        {
+                            GDALDataset::SetMetadataItem(
+                                pszKey, pszUnescapedValue, pszDomain);
+                        }
+                    }
+                    else
+                    {
+                        auto poBand = cpl::down_cast<LIBERTIFFBand *>(
+                            GetRasterBand(nBand));
+                        if (poBand != nullptr)
+                        {
+                            if (EQUAL(pszRole, "scale"))
+                            {
+                                poBand->m_bHaveOffsetScale = true;
+                                poBand->m_dfScale = CPLAtofM(pszUnescapedValue);
+                            }
+                            else if (EQUAL(pszRole, "offset"))
+                            {
+                                poBand->m_bHaveOffsetScale = true;
+                                poBand->m_dfOffset =
+                                    CPLAtofM(pszUnescapedValue);
+                            }
+                            else if (EQUAL(pszRole, "unittype"))
+                            {
+                                poBand->m_osUnitType = pszUnescapedValue;
+                            }
+                            else if (EQUAL(pszRole, "description"))
+                            {
+                                poBand->m_osDescription = pszUnescapedValue;
+                            }
+                            else if (EQUAL(pszRole, "colorinterp"))
+                            {
+                                if (EQUAL(pszUnescapedValue, "undefined"))
+                                    poBand->m_eColorInterp = GCI_Undefined;
+                                else
+                                {
+                                    poBand->m_eColorInterp =
+                                        GDALGetColorInterpretationByName(
+                                            pszUnescapedValue);
+                                    if (poBand->m_eColorInterp == GCI_Undefined)
+                                    {
+                                        poBand->GDALRasterBand::SetMetadataItem(
+                                            "COLOR_INTERPRETATION",
+                                            pszUnescapedValue);
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                if (bIsXML)
+                                {
+                                    char *apszMD[2] = {pszUnescapedValue,
+                                                       nullptr};
+                                    poBand->GDALRasterBand::SetMetadata(
+                                        apszMD, pszDomain);
+                                }
+                                else
+                                {
+                                    poBand->GDALRasterBand::SetMetadataItem(
+                                        pszKey, pszUnescapedValue, pszDomain);
+                                }
+                            }
+                        }
+                    }
+                    CPLFree(pszUnescapedValue);
+                }
+            }
+        }
+    }
+
+    if ((m_image->compression() == LIBERTIFF_NS::Compression::WEBP ||
+         m_image->compression() == LIBERTIFF_NS::Compression::JXL ||
+         m_image->compression() == LIBERTIFF_NS::Compression::JXL_DNG_1_7) &&
+        GetMetadataItem("COMPRESSION_REVERSIBILITY", "IMAGE_STRUCTURE") ==
+            nullptr)
+    {
+        const char *pszDriverName =
+            m_image->compression() == LIBERTIFF_NS::Compression::WEBP
+                ? "WEBP"
+                : "JPEGXL";
+        auto poTileDriver = GDALGetDriverByName(pszDriverName);
+        if (poTileDriver)
+        {
+            bool ok = true;
+            const uint64_t offset = m_image->strileOffset(0, ok);
+            const uint64_t bytecount = m_image->strileByteCount(0, ok);
+            if (ok && bytecount > 0)
+            {
+                const std::string osSubfile(
+                    CPLSPrintf("/vsisubfile/" CPL_FRMT_GUIB "_%d,%s",
+                               static_cast<GUIntBig>(offset),
+                               static_cast<int>(std::min(
+                                   static_cast<uint64_t>(1024), bytecount)),
+                               GetDescription()));
+                const char *const apszDrivers[] = {pszDriverName, nullptr};
+                auto poTileDataset =
+                    std::unique_ptr<GDALDataset>(GDALDataset::Open(
+                        osSubfile.c_str(), GDAL_OF_RASTER, apszDrivers));
+                if (poTileDataset)
+                {
+                    const char *pszReversibility =
+                        poTileDataset->GetMetadataItem(
+                            "COMPRESSION_REVERSIBILITY", "IMAGE_STRUCTURE");
+                    if (pszReversibility)
+                        GDALDataset::SetMetadataItem(
+                            "COMPRESSION_REVERSIBILITY", pszReversibility,
+                            "IMAGE_STRUCTURE");
+                }
+            }
+        }
+    }
+
+    // Init mask bands
+    for (int i = 0; i < nBands; ++i)
+    {
+        cpl::down_cast<LIBERTIFFBand *>(papoBands[i])->InitMaskBand();
+    }
+    for (auto &poOvrDS : m_apoOvrDS)
+    {
+        for (int i = 0; i < nBands; ++i)
+        {
+            cpl::down_cast<LIBERTIFFBand *>(poOvrDS->papoBands[i])
+                ->InitMaskBand();
+        }
+    }
+
+    m_fileReader->setPReadAllowed();
+
+    if (poOpenInfo->fpL)
+    {
+        m_poFile.reset(poOpenInfo->fpL);
+        poOpenInfo->fpL = nullptr;
+    }
+
+    return true;
+}
+
+/************************************************************************/
+/*                             ReadSRS()                                */
+/************************************************************************/
+
+// Simplified GeoTIFF SRS reader, assuming the SRS is encoded as a EPSG code
+void LIBERTIFFDataset::ReadSRS()
+{
+    const auto psGeoKeysTag =
+        m_image->tag(LIBERTIFF_NS::TagCode::GeoTIFFGeoKeyDirectory);
+    constexpr int VALUES_PER_GEOKEY = 4;
+    if (psGeoKeysTag && psGeoKeysTag->type == LIBERTIFF_NS::TagType::Short &&
+        !psGeoKeysTag->invalid_value_offset &&
+        psGeoKeysTag->count >= VALUES_PER_GEOKEY &&
+        (psGeoKeysTag->count % VALUES_PER_GEOKEY) == 0 &&
+        // Sanity check
+        psGeoKeysTag->count < 1000)
+    {
+        bool ok = true;
+        const auto values =
+            m_image->readTagAsVector<uint16_t>(*psGeoKeysTag, ok);
+        if (values.size() >= 4)
+        {
+            const uint16_t geokeysCount = values[3];
+            constexpr uint16_t GEOTIFF_KEY_DIRECTORY_VERSION_V1 = 1;
+            constexpr uint16_t GEOTIFF_KEY_VERSION_MAJOR_V1 = 1;
+            if (values[0] == GEOTIFF_KEY_DIRECTORY_VERSION_V1 &&
+                // GeoTIFF 1.x
+                values[1] == GEOTIFF_KEY_VERSION_MAJOR_V1 &&
+                // No equality for autotest/gcore/data/ycbcr_with_mask.tif
+                geokeysCount <= psGeoKeysTag->count / VALUES_PER_GEOKEY - 1)
+            {
+                constexpr uint16_t GeoTIFFTypeShort = 0;
+                constexpr uint16_t GeoTIFFTypeDouble =
+                    LIBERTIFF_NS::TagCode::GeoTIFFDoubleParams;
+
+                constexpr uint16_t GTModelTypeGeoKey = 1024;
+                constexpr uint16_t ModelTypeProjected = 1;
+                constexpr uint16_t ModelTypeGeographic = 2;
+
+                constexpr uint16_t GTRasterTypeGeoKey = 1025;
+                constexpr uint16_t RasterPixelIsArea = 1;
+                constexpr uint16_t RasterPixelIsPoint = 2;
+
+                constexpr uint16_t GeodeticCRSGeoKey = 2048;
+                constexpr uint16_t ProjectedCRSGeoKey = 3072;
+
+                constexpr uint16_t VerticalGeoKey = 4096;
+
+                constexpr uint16_t CoordinateEpochGeoKey = 5120;
+
+                uint16_t nModelType = 0;
+                uint16_t nEPSGCode = 0;
+                uint16_t nEPSGCodeVertical = 0;
+                double dfCoordEpoch = 0;
+                bool bHasCoordEpoch = false;
+                for (uint32_t i = 1; i <= geokeysCount; ++i)
+                {
+                    const auto geokey = values[VALUES_PER_GEOKEY * i];
+                    const auto geokeyType = values[VALUES_PER_GEOKEY * i + 1];
+                    const auto geokeyCount = values[VALUES_PER_GEOKEY * i + 2];
+                    const auto geokeyValue = values[VALUES_PER_GEOKEY * i + 3];
+                    if (geokey == GTModelTypeGeoKey)
+                    {
+                        nModelType = geokeyValue;
+                    }
+                    else if (geokey == GeodeticCRSGeoKey &&
+                             nModelType == ModelTypeGeographic &&
+                             geokeyType == GeoTIFFTypeShort &&
+                             geokeyCount == 1 && geokeyValue > 0)
+                    {
+                        nEPSGCode = geokeyValue;
+                    }
+                    else if (geokey == ProjectedCRSGeoKey &&
+                             nModelType == ModelTypeProjected &&
+                             geokeyType == GeoTIFFTypeShort &&
+                             geokeyCount == 1 && geokeyValue > 0)
+                    {
+                        nEPSGCode = geokeyValue;
+                    }
+                    else if (geokey == GTRasterTypeGeoKey &&
+                             geokeyType == GeoTIFFTypeShort && geokeyCount == 1)
+                    {
+                        if (geokeyValue == RasterPixelIsArea)
+                        {
+                            GDALDataset::SetMetadataItem(GDALMD_AREA_OR_POINT,
+                                                         GDALMD_AOP_AREA);
+                        }
+                        else if (geokeyValue == RasterPixelIsPoint)
+                        {
+                            GDALDataset::SetMetadataItem(GDALMD_AREA_OR_POINT,
+                                                         GDALMD_AOP_POINT);
+                        }
+                    }
+                    else if (values[2] == 1 /* GeoTIFF 1.1 */ &&
+                             geokey == VerticalGeoKey &&
+                             geokeyType == GeoTIFFTypeShort && geokeyCount == 1)
+                    {
+                        nEPSGCodeVertical = geokeyValue;
+                    }
+                    else if (geokey == CoordinateEpochGeoKey &&
+                             geokeyType == GeoTIFFTypeDouble &&
+                             geokeyCount == 1)
+                    {
+                        const auto psGeoDoubleParamsTag = m_image->tag(
+                            LIBERTIFF_NS::TagCode::GeoTIFFDoubleParams);
+                        if (psGeoDoubleParamsTag &&
+                            psGeoDoubleParamsTag->type ==
+                                LIBERTIFF_NS::TagType::Double &&
+                            psGeoDoubleParamsTag->count > geokeyValue)
+                        {
+                            ok = true;
+                            const auto doubleValues =
+                                m_image->readTagAsVector<double>(
+                                    *psGeoDoubleParamsTag, ok);
+                            if (ok && doubleValues.size() > geokeyValue)
+                            {
+                                bHasCoordEpoch = true;
+                                dfCoordEpoch = doubleValues[geokeyValue];
+                            }
+                        }
+                    }
+                }
+
+                if (nEPSGCode > 0 && nEPSGCode != 32767 &&
+                    nEPSGCodeVertical != 32767)
+                {
+                    m_oSRS.importFromEPSG(nEPSGCode);
+
+                    if (nEPSGCodeVertical > 0)
+                    {
+                        OGRSpatialReference oSRSVertical;
+                        oSRSVertical.importFromEPSG(nEPSGCodeVertical);
+                        if (oSRSVertical.IsGeographic() &&
+                            oSRSVertical.GetAxesCount() == 3)
+                        {
+                            m_oSRS = std::move(oSRSVertical);
+                        }
+                        else
+                        {
+                            m_oSRS.SetFromUserInput(CPLSPrintf(
+                                "EPSG:%d+%d", nEPSGCode, nEPSGCodeVertical));
+                        }
+                    }
+
+                    m_oSRS.SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
+                    if (bHasCoordEpoch)
+                        m_oSRS.SetCoordinateEpoch(dfCoordEpoch);
+                    return;
+                }
+
+                const char *const apszAllowedDrivers[] = {"GTiff", nullptr};
+                auto poTmpDS = std::unique_ptr<GDALDataset>(GDALDataset::Open(
+                    GetDescription(), GDAL_OF_RASTER | GDAL_OF_INTERNAL,
+                    apszAllowedDrivers, nullptr, nullptr));
+                if (poTmpDS)
+                {
+                    const OGRSpatialReference *poSRS = poTmpDS->GetSpatialRef();
+                    if (!poSRS)
+                        poSRS = poTmpDS->GetGCPSpatialRef();
+                    if (poSRS)
+                        m_oSRS = *poSRS;
+                }
+            }
+        }
+    }
+}
+
+/************************************************************************/
+/*                       ReadGeoTransform()                             */
+/************************************************************************/
+
+void LIBERTIFFDataset::ReadGeoTransform()
+{
+    // Number of values per GCP in the GeoTIFFTiePoints tag
+    constexpr int VALUES_PER_GCP = 6;
+
+    constexpr int GCP_PIXEL = 0;
+    constexpr int GCP_LINE = 1;
+    // constexpr int GCP_DEPTH = 2;
+    constexpr int GCP_X = 3;
+    constexpr int GCP_Y = 4;
+    constexpr int GCP_Z = 5;
+
+    const auto *psTagTiePoints =
+        m_image->tag(LIBERTIFF_NS::TagCode::GeoTIFFTiePoints);
+    const auto *psTagPixelScale =
+        m_image->tag(LIBERTIFF_NS::TagCode::GeoTIFFPixelScale);
+    const auto *psTagGeoTransMatrix =
+        m_image->tag(LIBERTIFF_NS::TagCode::GeoTIFFGeoTransMatrix);
+    if (psTagTiePoints &&
+        psTagTiePoints->type == LIBERTIFF_NS::TagType::Double &&
+        !psTagTiePoints->invalid_value_offset &&
+        psTagTiePoints->count == VALUES_PER_GCP && psTagPixelScale &&
+        psTagPixelScale->type == LIBERTIFF_NS::TagType::Double &&
+        !psTagPixelScale->invalid_value_offset && psTagPixelScale->count == 3)
+    {
+        bool ok = true;
+        const auto tiepoints =
+            m_image->readTagAsVector<double>(*psTagTiePoints, ok);
+        const auto pixelScale =
+            m_image->readTagAsVector<double>(*psTagPixelScale, ok);
+        if (!ok)
+            return;
+
+        m_geotransformValid = true;
+        m_geotransform[1] = pixelScale[GCP_PIXEL];
+        m_geotransform[5] = -pixelScale[GCP_LINE];
+        m_geotransform[0] =
+            tiepoints[GCP_X] - tiepoints[GCP_PIXEL] * m_geotransform[1];
+        m_geotransform[3] =
+            tiepoints[GCP_Y] - tiepoints[GCP_LINE] * m_geotransform[5];
+    }
+    else if (psTagGeoTransMatrix &&
+             psTagGeoTransMatrix->type == LIBERTIFF_NS::TagType::Double &&
+             !psTagGeoTransMatrix->invalid_value_offset &&
+             psTagGeoTransMatrix->count == 16)
+    {
+        bool ok = true;
+        const auto matrix =
+            m_image->readTagAsVector<double>(*psTagGeoTransMatrix, ok);
+        if (ok)
+        {
+            m_geotransformValid = true;
+            m_geotransform[0] = matrix[3];
+            m_geotransform[1] = matrix[0];
+            m_geotransform[2] = matrix[1];
+            m_geotransform[3] = matrix[7];
+            m_geotransform[4] = matrix[4];
+            m_geotransform[5] = matrix[5];
+        }
+    }
+    else if (psTagTiePoints &&
+             psTagTiePoints->type == LIBERTIFF_NS::TagType::Double &&
+             !psTagTiePoints->invalid_value_offset &&
+             psTagTiePoints->count > VALUES_PER_GCP &&
+             (psTagTiePoints->count % VALUES_PER_GCP) == 0 &&
+             psTagTiePoints->count <= 10000 * VALUES_PER_GCP)
+    {
+        bool ok = true;
+        const auto tiepoints =
+            m_image->readTagAsVector<double>(*psTagTiePoints, ok);
+        if (ok)
+        {
+            bool pixelIsPoint = false;
+            if (const char *pszAreaOrPoint =
+                    GetMetadataItem(GDALMD_AREA_OR_POINT))
+            {
+                pixelIsPoint = EQUAL(pszAreaOrPoint, GDALMD_AOP_POINT);
+            }
+            const int gcpCount =
+                static_cast<int>(psTagTiePoints->count / VALUES_PER_GCP);
+            for (int iGCP = 0; iGCP < gcpCount; ++iGCP)
+            {
+                m_aoGCPs.emplace_back(
+                    CPLSPrintf("%d", iGCP + 1), "",
+                    /* pixel = */ tiepoints[iGCP * VALUES_PER_GCP + GCP_PIXEL],
+                    /* line = */ tiepoints[iGCP * VALUES_PER_GCP + GCP_LINE],
+                    /* X = */ tiepoints[iGCP * VALUES_PER_GCP + GCP_X],
+                    /* Y = */ tiepoints[iGCP * VALUES_PER_GCP + GCP_Y],
+                    /* Z = */ tiepoints[iGCP * VALUES_PER_GCP + GCP_Z]);
+
+                if (pixelIsPoint)
+                {
+                    m_aoGCPs.back().Pixel() += 0.5;
+                    m_aoGCPs.back().Line() += 0.5;
+                }
+            }
+        }
+    }
+
+    if (m_geotransformValid)
+    {
+        if (const char *pszAreaOrPoint = GetMetadataItem(GDALMD_AREA_OR_POINT))
+        {
+            if (EQUAL(pszAreaOrPoint, GDALMD_AOP_POINT))
+            {
+                m_geotransform[0] -=
+                    (m_geotransform[1] * 0.5 + m_geotransform[2] * 0.5);
+                m_geotransform[3] -=
+                    (m_geotransform[4] * 0.5 + m_geotransform[5] * 0.5);
+            }
+        }
+    }
+}
+
+/************************************************************************/
+/*                             ReadRPCTag()                             */
+/*                                                                      */
+/*      Format a TAG according to:                                      */
+/*                                                                      */
+/*      http://geotiff.maptools.org/rpc_prop.html                       */
+/************************************************************************/
+
+void LIBERTIFFDataset::ReadRPCTag()
+
+{
+    const auto *psTagRPCCoefficients =
+        m_image->tag(LIBERTIFF_NS::TagCode::RPCCoefficients);
+    if (psTagRPCCoefficients &&
+        psTagRPCCoefficients->type == LIBERTIFF_NS::TagType::Double &&
+        !psTagRPCCoefficients->invalid_value_offset &&
+        psTagRPCCoefficients->count == 92)
+    {
+        bool ok = true;
+        const auto adfRPC =
+            m_image->readTagAsVector<double>(*psTagRPCCoefficients, ok);
+        if (ok && adfRPC.size() == 92)
+        {
+            CPLStringList asMD;
+            asMD.SetNameValue(RPC_ERR_BIAS, CPLOPrintf("%.15g", adfRPC[0]));
+            asMD.SetNameValue(RPC_ERR_RAND, CPLOPrintf("%.15g", adfRPC[1]));
+            asMD.SetNameValue(RPC_LINE_OFF, CPLOPrintf("%.15g", adfRPC[2]));
+            asMD.SetNameValue(RPC_SAMP_OFF, CPLOPrintf("%.15g", adfRPC[3]));
+            asMD.SetNameValue(RPC_LAT_OFF, CPLOPrintf("%.15g", adfRPC[4]));
+            asMD.SetNameValue(RPC_LONG_OFF, CPLOPrintf("%.15g", adfRPC[5]));
+            asMD.SetNameValue(RPC_HEIGHT_OFF, CPLOPrintf("%.15g", adfRPC[6]));
+            asMD.SetNameValue(RPC_LINE_SCALE, CPLOPrintf("%.15g", adfRPC[7]));
+            asMD.SetNameValue(RPC_SAMP_SCALE, CPLOPrintf("%.15g", adfRPC[8]));
+            asMD.SetNameValue(RPC_LAT_SCALE, CPLOPrintf("%.15g", adfRPC[9]));
+            asMD.SetNameValue(RPC_LONG_SCALE, CPLOPrintf("%.15g", adfRPC[10]));
+            asMD.SetNameValue(RPC_HEIGHT_SCALE,
+                              CPLOPrintf("%.15g", adfRPC[11]));
+
+            CPLString osField;
+            CPLString osMultiField;
+
+            for (int i = 0; i < 20; ++i)
+            {
+                osField.Printf("%.15g", adfRPC[12 + i]);
+                if (i > 0)
+                    osMultiField += " ";
+                else
+                    osMultiField = "";
+                osMultiField += osField;
+            }
+            asMD.SetNameValue(RPC_LINE_NUM_COEFF, osMultiField);
+
+            for (int i = 0; i < 20; ++i)
+            {
+                osField.Printf("%.15g", adfRPC[32 + i]);
+                if (i > 0)
+                    osMultiField += " ";
+                else
+                    osMultiField = "";
+                osMultiField += osField;
+            }
+            asMD.SetNameValue(RPC_LINE_DEN_COEFF, osMultiField);
+
+            for (int i = 0; i < 20; ++i)
+            {
+                osField.Printf("%.15g", adfRPC[52 + i]);
+                if (i > 0)
+                    osMultiField += " ";
+                else
+                    osMultiField = "";
+                osMultiField += osField;
+            }
+            asMD.SetNameValue(RPC_SAMP_NUM_COEFF, osMultiField);
+
+            for (int i = 0; i < 20; ++i)
+            {
+                osField.Printf("%.15g", adfRPC[72 + i]);
+                if (i > 0)
+                    osMultiField += " ";
+                else
+                    osMultiField = "";
+                osMultiField += osField;
+            }
+            asMD.SetNameValue(RPC_SAMP_DEN_COEFF, osMultiField);
+
+            GDALDataset::SetMetadata(asMD.List(), "RPC");
+        }
+    }
+}
+
+/************************************************************************/
+/*                           OpenStatic()                               */
+/************************************************************************/
+
+/* static */ GDALDataset *LIBERTIFFDataset::OpenStatic(GDALOpenInfo *poOpenInfo)
+{
+    if (!Identify(poOpenInfo))
+        return nullptr;
+
+    auto poDS = std::make_unique<LIBERTIFFDataset>();
+    if (!poDS->Open(poOpenInfo))
+        return nullptr;
+    return poDS.release();
+}
+
+/************************************************************************/
+/*                       GDALRegister_LIBERTIFF()                       */
+/************************************************************************/
+
+void GDALRegister_LIBERTIFF()
+
+{
+    if (GDALGetDriverByName("LIBERTIFF") != nullptr)
+        return;
+
+    auto poDriver = std::make_unique<GDALDriver>();
+    poDriver->SetDescription("LIBERTIFF");
+    poDriver->SetMetadataItem(GDAL_DCAP_RASTER, "YES");
+    poDriver->SetMetadataItem(GDAL_DMD_LONGNAME,
+                              "GeoTIFF (using LIBERTIFF library)");
+    poDriver->SetMetadataItem(GDAL_DMD_HELPTOPIC,
+                              "drivers/raster/libertiff.html");
+    poDriver->SetMetadataItem(GDAL_DMD_MIMETYPE, "image/tiff");
+    poDriver->SetMetadataItem(GDAL_DMD_EXTENSIONS, "tif tiff");
+    poDriver->SetMetadataItem(GDAL_DCAP_VIRTUALIO, "YES");
+    poDriver->SetMetadataItem(GDAL_DCAP_COORDINATE_EPOCH, "YES");
+
+    poDriver->pfnIdentify = LIBERTIFFDataset::Identify;
+    poDriver->pfnOpen = LIBERTIFFDataset::OpenStatic;
+
+    if (CPLGetDecompressor("lzma"))
+    {
+        poDriver->SetMetadataItem("LZMA_SUPPORT", "YES", "LIBERTIFF");
+    }
+#ifdef ZSTD_SUPPORT
+    poDriver->SetMetadataItem("ZSTD_SUPPORT", "YES", "LIBERTIFF");
+#endif
+#if defined(LERC_SUPPORT)
+    poDriver->SetMetadataItem("LERC_SUPPORT", "YES", "LIBERTIFF");
+#if defined(LERC_VERSION_MAJOR)
+    poDriver->SetMetadataItem("LERC_VERSION_MAJOR",
+                              XSTRINGIFY(LERC_VERSION_MAJOR), "LERC");
+    poDriver->SetMetadataItem("LERC_VERSION_MINOR",
+                              XSTRINGIFY(LERC_VERSION_MINOR), "LERC");
+    poDriver->SetMetadataItem("LERC_VERSION_PATCH",
+                              XSTRINGIFY(LERC_VERSION_PATCH), "LERC");
+#endif
+#endif
+
+    GetGDALDriverManager()->RegisterDriver(poDriver.release());
+}
diff --git a/frmts/libertiff/libtiff_codecs.h b/frmts/libertiff/libtiff_codecs.h
new file mode 100644
index 000000000000..60fd454f0e25
--- /dev/null
+++ b/frmts/libertiff/libtiff_codecs.h
@@ -0,0 +1,180 @@
+/******************************************************************************
+ *
+ * Project:  GDAL Core
+ * Purpose:  GeoTIFF thread safe reader using libertiff library.
+ * Author:   Even Rouault <even dot rouault at spatialys.com>
+ *
+ ******************************************************************************
+ * Copyright (c) 2024, Even Rouault <even dot rouault at spatialys.com>
+ *
+ * SPDX-License-Identifier: MIT
+ ****************************************************************************/
+
+// Use code from internal libtiff for LZW, PackBits and LERC codecs
+#define TIFFInitLZW LIBERTIFF_TIFFInitLZW
+#define TIFFInitPackBits LIBERTIFF_TIFFInitPackBits
+#define TIFFInitLERC LIBERTIFF_TIFFInitLERC
+#define _TIFFmallocExt LIBERTIFF_TIFFmallocExt
+#define _TIFFreallocExt LIBERTIFF_TIFFreallocExt
+#define _TIFFcallocExt LIBERTIFF_TIFFcallocExt
+#define _TIFFfreeExt LIBERTIFF_TIFFfreeExt
+#define _TIFFmemset LIBERTIFF_TIFFmemset
+#define _TIFFmemcpy LIBERTIFF_TIFFmemcpy
+#define TIFFPredictorInit LIBERTIFF_TIFFPredictorInit
+#define TIFFPredictorCleanup LIBERTIFF_TIFFPredictorCleanup
+#define _TIFFSetDefaultCompressionState LIBERTIFF_TIFFSetDefaultCompressionState
+#define TIFFFlushData1 LIBERTIFF_TIFFFlushData1_dummy
+#define TIFFWarningExtR LIBERTIFF_TIFFWarningExtR
+#define TIFFErrorExtR LIBERTIFF_TIFFErrorExtR
+#define TIFFTileRowSize LIBERTIFF_TIFFTileRowSize_dummy
+#define TIFFScanlineSize LIBERTIFF_TIFFScanlineSize_dummy
+#define TIFFSetField LIBERTIFF_TIFFSetField_dummy
+#define _TIFFMergeFields LIBERTIFF_TIFFMergeFields_dummy
+#define register
+extern "C"
+{
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#endif
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
+#endif
+
+#define LZW_READ_ONLY
+#include "tif_lzw.c"
+
+#define PACKBITS_READ_ONLY
+#include "tif_packbits.c"
+
+#ifdef LERC_SUPPORT
+#define LERC_READ_ONLY
+#include "tif_lerc.c"
+#endif
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+    void *LIBERTIFF_TIFFmallocExt(TIFF *, tmsize_t s)
+    {
+        return malloc(s);
+    }
+
+    void *LIBERTIFF_TIFFreallocExt(TIFF *, void *p, tmsize_t s)
+    {
+        return realloc(p, s);
+    }
+
+    void *LIBERTIFF_TIFFcallocExt(TIFF *, tmsize_t nmemb, tmsize_t siz)
+    {
+        return calloc(nmemb, siz);
+    }
+
+    void LIBERTIFF_TIFFfreeExt(TIFF *, void *ptr)
+    {
+        free(ptr);
+    }
+
+    void LIBERTIFF_TIFFmemset(void *ptr, int v, tmsize_t s)
+    {
+        memset(ptr, v, s);
+    }
+
+    void LIBERTIFF_TIFFmemcpy(void *d, const void *s, tmsize_t c)
+    {
+        memcpy(d, s, c);
+    }
+
+    void LIBERTIFF_TIFFSetDefaultCompressionState(TIFF *)
+    {
+    }
+
+    int LIBERTIFF_TIFFSetField_dummy(TIFF *, uint32_t, ...)
+    {
+        return 0;
+    }
+
+    int LIBERTIFF_TIFFMergeFields_dummy(TIFF *, const TIFFField[], uint32_t)
+    {
+        return 1;
+    }
+
+    int LIBERTIFF_TIFFPredictorInit(TIFF *)
+    {
+        return 0;
+    }
+
+    int LIBERTIFF_TIFFPredictorCleanup(TIFF *)
+    {
+        return 0;
+    }
+
+    /************************************************************************/
+    /*                       PrepareTIFFErrorFormat()                       */
+    /*                                                                      */
+    /*      sometimes the "module" has stuff in it that has special         */
+    /*      meaning in a printf() style format, so we try to escape it.     */
+    /*      For now we hope the only thing we have to escape is %'s.        */
+    /************************************************************************/
+
+    static char *PrepareTIFFErrorFormat(const char *module, const char *fmt)
+
+    {
+        const size_t nModuleSize = strlen(module);
+        const size_t nModFmtSize = nModuleSize * 2 + strlen(fmt) + 2;
+        char *pszModFmt = static_cast<char *>(CPLMalloc(nModFmtSize));
+
+        size_t iOut = 0;  // Used after for.
+
+        for (size_t iIn = 0; iIn < nModuleSize; ++iIn)
+        {
+            if (module[iIn] == '%')
+            {
+                CPLAssert(iOut < nModFmtSize - 2);
+                pszModFmt[iOut++] = '%';
+                pszModFmt[iOut++] = '%';
+            }
+            else
+            {
+                CPLAssert(iOut < nModFmtSize - 1);
+                pszModFmt[iOut++] = module[iIn];
+            }
+        }
+        CPLAssert(iOut < nModFmtSize);
+        pszModFmt[iOut] = '\0';
+        strcat(pszModFmt, ":");
+        strcat(pszModFmt, fmt);
+
+        return pszModFmt;
+    }
+
+    void LIBERTIFF_TIFFWarningExtR(TIFF *, const char *pszModule,
+                                   const char *fmt, ...)
+    {
+        char *pszModFmt = PrepareTIFFErrorFormat(pszModule, fmt);
+        va_list ap;
+        va_start(ap, fmt);
+        CPLErrorV(CE_Warning, CPLE_AppDefined, pszModFmt, ap);
+        va_end(ap);
+        CPLFree(pszModFmt);
+    }
+
+    void LIBERTIFF_TIFFErrorExtR(TIFF *, const char *pszModule, const char *fmt,
+                                 ...)
+    {
+        char *pszModFmt = PrepareTIFFErrorFormat(pszModule, fmt);
+        va_list ap;
+        va_start(ap, fmt);
+        CPLErrorV(CE_Failure, CPLE_AppDefined, pszModFmt, ap);
+        va_end(ap);
+        CPLFree(pszModFmt);
+    }
+}
+#undef isTiled
diff --git a/gcore/gdal_frmts.h b/gcore/gdal_frmts.h
index 610b12ddb07a..e957afc14719 100644
--- a/gcore/gdal_frmts.h
+++ b/gcore/gdal_frmts.h
@@ -18,6 +18,7 @@
 
 CPL_C_START
 void CPL_DLL GDALRegister_GTiff(void);
+void CPL_DLL GDALRegister_LIBERTIFF(void);
 void CPL_DLL GDALRegister_GXF(void);
 void CPL_DLL GDALRegister_HFA(void);
 void CPL_DLL GDALRegister_AAIGrid(void);
diff --git a/gcore/gdal_priv.h b/gcore/gdal_priv.h
index 269b8789f300..bed0695c1814 100644
--- a/gcore/gdal_priv.h
+++ b/gcore/gdal_priv.h
@@ -1574,6 +1574,12 @@ class CPL_DLL GDALRasterBand : public GDALMajorObject
             m_poBandRef = bOwned ? nullptr : poBand;
         }
 
+        void reset(std::unique_ptr<GDALRasterBand> poBand)
+        {
+            m_poBandOwned = std::move(poBand);
+            m_poBandRef = nullptr;
+        }
+
         const GDALRasterBand *get() const
         {
             return static_cast<const GDALRasterBand *>(*this);
@@ -1968,6 +1974,12 @@ class CPL_DLL GDALAllValidMaskBand : public GDALRasterBand
   protected:
     CPLErr IReadBlock(int, int, void *) override;
 
+    CPLErr IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize,
+                     int nYSize, void *pData, int nBufXSize, int nBufYSize,
+                     GDALDataType eBufType, GSpacing nPixelSpace,
+                     GSpacing nLineSpace,
+                     GDALRasterIOExtraArg *psExtraArg) override;
+
     CPL_DISALLOW_COPY_ASSIGN(GDALAllValidMaskBand)
 
   public:
diff --git a/gcore/gdalallvalidmaskband.cpp b/gcore/gdalallvalidmaskband.cpp
index cc44b5045de7..b34bee6a18c4 100644
--- a/gcore/gdalallvalidmaskband.cpp
+++ b/gcore/gdalallvalidmaskband.cpp
@@ -55,6 +55,33 @@ CPLErr GDALAllValidMaskBand::IReadBlock(int /* nXBlockOff */,
     return CE_None;
 }
 
+/************************************************************************/
+/*                             IRasterIO()                              */
+/************************************************************************/
+
+CPLErr GDALAllValidMaskBand::IRasterIO(GDALRWFlag eRWFlag, int, int, int, int,
+                                       void *pData, int nBufXSize,
+                                       int nBufYSize, GDALDataType eBufType,
+                                       GSpacing nPixelSpace,
+                                       GSpacing nLineSpace,
+                                       GDALRasterIOExtraArg *)
+{
+    if (eRWFlag != GF_Read)
+    {
+        return CE_Failure;
+    }
+
+    GByte *pabyData = static_cast<GByte *>(pData);
+    GByte byVal = 255;
+    for (int iY = 0; iY < nBufYSize; ++iY)
+    {
+        GDALCopyWords64(&byVal, GDT_Byte, 0, pabyData + iY * nLineSpace,
+                        eBufType, static_cast<int>(nPixelSpace), nBufXSize);
+    }
+
+    return CE_None;
+}
+
 /************************************************************************/
 /*                            GetMaskBand()                             */
 /************************************************************************/
diff --git a/swig/python/gdal-utils/osgeo_utils/samples/validate_cloud_optimized_geotiff.py b/swig/python/gdal-utils/osgeo_utils/samples/validate_cloud_optimized_geotiff.py
index 52e087e55128..22ccaa6d2179 100644
--- a/swig/python/gdal-utils/osgeo_utils/samples/validate_cloud_optimized_geotiff.py
+++ b/swig/python/gdal-utils/osgeo_utils/samples/validate_cloud_optimized_geotiff.py
@@ -162,7 +162,7 @@ def validate(ds, check_tiled=True, full_check=False):
             raise ValidateCloudOptimizedGeoTIFFException(
                 "Invalid file : %s" % gdal.GetLastErrorMsg()
             )
-        if ds.GetDriver().ShortName != "GTiff":
+        if ds.GetDriver().ShortName not in ("GTiff", "LIBERTIFF"):
             raise ValidateCloudOptimizedGeoTIFFException("The file is not a GeoTIFF")
 
     details = {}
diff --git a/third_party/libertiff/libertiff.hpp b/third_party/libertiff/libertiff.hpp
index 5275b6115d2b..e50a8f08c1d0 100644
--- a/third_party/libertiff/libertiff.hpp
+++ b/third_party/libertiff/libertiff.hpp
@@ -14,6 +14,7 @@
 #include <bit>  // std::endian
 #endif
 
+#include <algorithm>
 #include <array>
 #include <cassert>
 #include <cstring>
@@ -378,8 +379,8 @@ typedef uint16_t TagCodeType;
 /** TIFF tag codes */
 namespace TagCode
 {
-constexpr TagCodeType NewSubfileType = 254;
-constexpr TagCodeType SubfileType = 255;
+constexpr TagCodeType SubFileType = 254;
+constexpr TagCodeType OldSubFileType = 255;
 
 // Base line and extended TIFF tags
 constexpr TagCodeType ImageWidth = 256;
@@ -387,23 +388,33 @@ constexpr TagCodeType ImageLength = 257;
 constexpr TagCodeType BitsPerSample = 258;
 constexpr TagCodeType Compression = 259;
 constexpr TagCodeType PhotometricInterpretation = 262;
+constexpr TagCodeType DocumentName = 269;
 constexpr TagCodeType ImageDescription = 270;
 constexpr TagCodeType StripOffsets = 273;
 constexpr TagCodeType SamplesPerPixel = 277;
 constexpr TagCodeType RowsPerStrip = 278;
 constexpr TagCodeType StripByteCounts = 279;
 constexpr TagCodeType PlanarConfiguration = 284;
+constexpr TagCodeType Software = 305;
+constexpr TagCodeType DateTime = 306;
 constexpr TagCodeType Predictor = 317;
+constexpr TagCodeType ColorMap = 320;
 constexpr TagCodeType TileWidth = 322;
 constexpr TagCodeType TileLength = 323;
 constexpr TagCodeType TileOffsets = 324;
 constexpr TagCodeType TileByteCounts = 325;
+constexpr TagCodeType ExtraSamples = 338;
 constexpr TagCodeType SampleFormat = 339;
+constexpr TagCodeType JPEGTables = 347;
+
+constexpr TagCodeType Copyright = 33432;
 
 // GeoTIFF tags
 constexpr TagCodeType GeoTIFFPixelScale = 33550;
 constexpr TagCodeType GeoTIFFTiePoints = 33922;
+constexpr TagCodeType GeoTIFFGeoTransMatrix = 34264;
 constexpr TagCodeType GeoTIFFGeoKeyDirectory = 34735;
+constexpr TagCodeType GeoTIFFDoubleParams = 34736;
 constexpr TagCodeType GeoTIFFAsciiParams = 34737;
 
 // GDAL tags
@@ -413,8 +424,20 @@ constexpr TagCodeType GDAL_NODATA = 42113;
 // GeoTIFF related
 constexpr TagCodeType RPCCoefficients = 50844;
 
+// LERC compression related
+constexpr TagCodeType LERCParameters =
+    50674; /* Stores LERC version and additional compression method */
+
 }  // namespace TagCode
 
+/** Binary or'ed value of SubFileType flags */
+namespace SubFileTypeFlags
+{
+constexpr uint32_t ReducedImage = 0x1; /* reduced resolution version */
+constexpr uint32_t Page = 0x2;         /* one page of many */
+constexpr uint32_t Mask = 0x4;         /* transparency mask */
+}  // namespace SubFileTypeFlags
+
 #define LIBERTIFF_CASE_TAGCODE_STR(x)                                          \
     case TagCode::x:                                                           \
         return #x
@@ -423,32 +446,42 @@ inline const char *tagCodeName(TagCodeType tagCode)
 {
     switch (tagCode)
     {
-        LIBERTIFF_CASE_TAGCODE_STR(NewSubfileType);
-        LIBERTIFF_CASE_TAGCODE_STR(SubfileType);
+        LIBERTIFF_CASE_TAGCODE_STR(SubFileType);
+        LIBERTIFF_CASE_TAGCODE_STR(OldSubFileType);
         LIBERTIFF_CASE_TAGCODE_STR(ImageWidth);
         LIBERTIFF_CASE_TAGCODE_STR(ImageLength);
         LIBERTIFF_CASE_TAGCODE_STR(BitsPerSample);
         LIBERTIFF_CASE_TAGCODE_STR(Compression);
         LIBERTIFF_CASE_TAGCODE_STR(PhotometricInterpretation);
+        LIBERTIFF_CASE_TAGCODE_STR(DocumentName);
         LIBERTIFF_CASE_TAGCODE_STR(ImageDescription);
         LIBERTIFF_CASE_TAGCODE_STR(StripOffsets);
         LIBERTIFF_CASE_TAGCODE_STR(SamplesPerPixel);
         LIBERTIFF_CASE_TAGCODE_STR(RowsPerStrip);
         LIBERTIFF_CASE_TAGCODE_STR(StripByteCounts);
         LIBERTIFF_CASE_TAGCODE_STR(PlanarConfiguration);
+        LIBERTIFF_CASE_TAGCODE_STR(Software);
+        LIBERTIFF_CASE_TAGCODE_STR(DateTime);
         LIBERTIFF_CASE_TAGCODE_STR(Predictor);
+        LIBERTIFF_CASE_TAGCODE_STR(ColorMap);
         LIBERTIFF_CASE_TAGCODE_STR(TileWidth);
         LIBERTIFF_CASE_TAGCODE_STR(TileLength);
         LIBERTIFF_CASE_TAGCODE_STR(TileOffsets);
         LIBERTIFF_CASE_TAGCODE_STR(TileByteCounts);
+        LIBERTIFF_CASE_TAGCODE_STR(ExtraSamples);
         LIBERTIFF_CASE_TAGCODE_STR(SampleFormat);
+        LIBERTIFF_CASE_TAGCODE_STR(Copyright);
+        LIBERTIFF_CASE_TAGCODE_STR(JPEGTables);
         LIBERTIFF_CASE_TAGCODE_STR(GeoTIFFPixelScale);
         LIBERTIFF_CASE_TAGCODE_STR(GeoTIFFTiePoints);
+        LIBERTIFF_CASE_TAGCODE_STR(GeoTIFFGeoTransMatrix);
         LIBERTIFF_CASE_TAGCODE_STR(GeoTIFFGeoKeyDirectory);
+        LIBERTIFF_CASE_TAGCODE_STR(GeoTIFFDoubleParams);
         LIBERTIFF_CASE_TAGCODE_STR(GeoTIFFAsciiParams);
         LIBERTIFF_CASE_TAGCODE_STR(GDAL_METADATA);
         LIBERTIFF_CASE_TAGCODE_STR(GDAL_NODATA);
         LIBERTIFF_CASE_TAGCODE_STR(RPCCoefficients);
+        LIBERTIFF_CASE_TAGCODE_STR(LERCParameters);
         default:
             break;
     }
@@ -606,7 +639,23 @@ constexpr CompressionType CCITT_FAX4 = 4;
 constexpr CompressionType LZW = 5;
 constexpr CompressionType OldJPEG = 6;
 constexpr CompressionType JPEG = 7;
-constexpr CompressionType Deflate = 8;
+constexpr CompressionType Deflate =
+    8; /* Deflate compression, as recognized by Adobe */
+constexpr CompressionType PackBits = 32773;
+constexpr CompressionType LegacyDeflate =
+    32946;                              /* Deflate compression, legacy tag */
+constexpr CompressionType JBIG = 34661; /* ISO JBIG */
+constexpr CompressionType LERC =
+    34887; /* ESRI Lerc codec: https://github.com/Esri/lerc */
+constexpr CompressionType LZMA = 34925; /* LZMA2 */
+constexpr CompressionType ZSTD =
+    50000; /* ZSTD: WARNING not registered in Adobe-maintained registry */
+constexpr CompressionType WEBP =
+    50001; /* WEBP: WARNING not registered in Adobe-maintained registry */
+constexpr CompressionType JXL =
+    50002; /* JPEGXL: WARNING not registered in Adobe-maintained registry */
+constexpr CompressionType JXL_DNG_1_7 =
+    52546; /* JPEGXL from DNG 1.7 specification */
 }  // namespace Compression
 
 #define LIBERTIFF_CASE_COMPRESSION_STR(x)                                      \
@@ -625,6 +674,15 @@ inline const char *compressionName(CompressionType compression)
         LIBERTIFF_CASE_COMPRESSION_STR(OldJPEG);
         LIBERTIFF_CASE_COMPRESSION_STR(JPEG);
         LIBERTIFF_CASE_COMPRESSION_STR(Deflate);
+        LIBERTIFF_CASE_COMPRESSION_STR(PackBits);
+        LIBERTIFF_CASE_COMPRESSION_STR(LegacyDeflate);
+        LIBERTIFF_CASE_COMPRESSION_STR(JBIG);
+        LIBERTIFF_CASE_COMPRESSION_STR(LERC);
+        LIBERTIFF_CASE_COMPRESSION_STR(LZMA);
+        LIBERTIFF_CASE_COMPRESSION_STR(ZSTD);
+        LIBERTIFF_CASE_COMPRESSION_STR(WEBP);
+        LIBERTIFF_CASE_COMPRESSION_STR(JXL);
+        LIBERTIFF_CASE_COMPRESSION_STR(JXL_DNG_1_7);
         default:
             break;
     }
@@ -669,6 +727,17 @@ inline const char *sampleFormatName(SampleFormatType sampleFormat)
 
 #undef LIBERTIFF_CASE_SAMPLE_FORMAT_STR
 
+/** Type of a ExtraSamples value */
+typedef uint32_t ExtraSamplesType;
+
+/** Values of the ExtraSamples tag */
+namespace ExtraSamples
+{
+constexpr ExtraSamplesType Unspecified = 0;
+constexpr ExtraSamplesType AssociatedAlpha = 1;   /* premultiplied */
+constexpr ExtraSamplesType UnAssociatedAlpha = 2; /* unpremultiplied */
+}  // namespace ExtraSamples
+
 /** Content of a tag entry in a Image File Directory (IFD) */
 struct TagEntry
 {
@@ -893,6 +962,12 @@ class Image
         return m_nextImageOffset;
     }
 
+    /** Return value of SubFileType tag */
+    inline uint32_t subFileType() const
+    {
+        return m_subFileType;
+    }
+
     /** Return width of the image in pixels */
     inline uint32_t width() const
     {
@@ -953,6 +1028,12 @@ class Image
         return m_rowsPerStrip;
     }
 
+    /** Return the sanitized number of rows per strip */
+    inline uint32_t rowsPerStripSanitized() const
+    {
+        return std::min(m_rowsPerStrip, m_height);
+    }
+
     /** Return the number of strips/tiles.
      * Return 0 if inconsistent values between ByteCounts and Offsets arrays. */
     inline uint64_t strileCount() const
@@ -1234,6 +1315,7 @@ class Image
     std::set<uint64_t> m_alreadyVisitedImageOffsets{};
     uint64_t m_offset = 0;
     uint64_t m_nextImageOffset = 0;
+    uint32_t m_subFileType = 0;
     uint32_t m_width = 0;
     uint32_t m_height = 0;
     uint32_t m_bitsPerSample = 0;
@@ -1268,6 +1350,10 @@ class Image
         {
             switch (entry.tag)
             {
+                case TagCode::SubFileType:
+                    m_subFileType = singleValue;
+                    break;
+
                 case TagCode::ImageWidth:
                     m_width = singleValue;
                     break;

From b611ad340addd01d9ab039f15f5eaf67156ceb9a Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Sat, 21 Dec 2024 16:59:40 +0100
Subject: [PATCH 06/40] Factor common code between GTiff and libertiff drivers

---
 frmts/gtiff/geotiff.cpp              | 112 +-------------
 frmts/gtiff/gtiffdataset_read.cpp    |  86 +----------
 frmts/libertiff/libertiffdataset.cpp | 161 ++-----------------
 frmts/libertiff/libtiff_codecs.h     |  47 +-----
 gcore/CMakeLists.txt                 |   4 +-
 gcore/tiff_common.cpp                | 223 +++++++++++++++++++++++++++
 gcore/tiff_common.h                  |  36 +++++
 7 files changed, 293 insertions(+), 376 deletions(-)
 create mode 100644 gcore/tiff_common.cpp
 create mode 100644 gcore/tiff_common.h

diff --git a/frmts/gtiff/geotiff.cpp b/frmts/gtiff/geotiff.cpp
index 877feb1dc7e7..13b9d2d107c7 100644
--- a/frmts/gtiff/geotiff.cpp
+++ b/frmts/gtiff/geotiff.cpp
@@ -15,6 +15,8 @@
 
 #include "gtiff.h"
 
+#include "tiff_common.h"
+
 #include "cpl_conv.h"
 #include "cpl_error.h"
 #include "gdal.h"
@@ -494,68 +496,7 @@ char **GTiffDatasetReadRPCTag(TIFF *hTIFF)
         nCount != 92)
         return nullptr;
 
-    CPLStringList asMD;
-    asMD.SetNameValue(RPC_ERR_BIAS, CPLOPrintf("%.15g", padfRPCTag[0]));
-    asMD.SetNameValue(RPC_ERR_RAND, CPLOPrintf("%.15g", padfRPCTag[1]));
-    asMD.SetNameValue(RPC_LINE_OFF, CPLOPrintf("%.15g", padfRPCTag[2]));
-    asMD.SetNameValue(RPC_SAMP_OFF, CPLOPrintf("%.15g", padfRPCTag[3]));
-    asMD.SetNameValue(RPC_LAT_OFF, CPLOPrintf("%.15g", padfRPCTag[4]));
-    asMD.SetNameValue(RPC_LONG_OFF, CPLOPrintf("%.15g", padfRPCTag[5]));
-    asMD.SetNameValue(RPC_HEIGHT_OFF, CPLOPrintf("%.15g", padfRPCTag[6]));
-    asMD.SetNameValue(RPC_LINE_SCALE, CPLOPrintf("%.15g", padfRPCTag[7]));
-    asMD.SetNameValue(RPC_SAMP_SCALE, CPLOPrintf("%.15g", padfRPCTag[8]));
-    asMD.SetNameValue(RPC_LAT_SCALE, CPLOPrintf("%.15g", padfRPCTag[9]));
-    asMD.SetNameValue(RPC_LONG_SCALE, CPLOPrintf("%.15g", padfRPCTag[10]));
-    asMD.SetNameValue(RPC_HEIGHT_SCALE, CPLOPrintf("%.15g", padfRPCTag[11]));
-
-    CPLString osField;
-    CPLString osMultiField;
-
-    for (int i = 0; i < 20; ++i)
-    {
-        osField.Printf("%.15g", padfRPCTag[12 + i]);
-        if (i > 0)
-            osMultiField += " ";
-        else
-            osMultiField = "";
-        osMultiField += osField;
-    }
-    asMD.SetNameValue(RPC_LINE_NUM_COEFF, osMultiField);
-
-    for (int i = 0; i < 20; ++i)
-    {
-        osField.Printf("%.15g", padfRPCTag[32 + i]);
-        if (i > 0)
-            osMultiField += " ";
-        else
-            osMultiField = "";
-        osMultiField += osField;
-    }
-    asMD.SetNameValue(RPC_LINE_DEN_COEFF, osMultiField);
-
-    for (int i = 0; i < 20; ++i)
-    {
-        osField.Printf("%.15g", padfRPCTag[52 + i]);
-        if (i > 0)
-            osMultiField += " ";
-        else
-            osMultiField = "";
-        osMultiField += osField;
-    }
-    asMD.SetNameValue(RPC_SAMP_NUM_COEFF, osMultiField);
-
-    for (int i = 0; i < 20; ++i)
-    {
-        osField.Printf("%.15g", padfRPCTag[72 + i]);
-        if (i > 0)
-            osMultiField += " ";
-        else
-            osMultiField = "";
-        osMultiField += osField;
-    }
-    asMD.SetNameValue(RPC_SAMP_DEN_COEFF, osMultiField);
-
-    return asMD.StealList();
+    return gdal::tiff_common::TIFFRPCTagToRPCMetadata(padfRPCTag).StealList();
 }
 
 /************************************************************************/
@@ -761,45 +702,6 @@ void GTiffWriteJPEGTables(TIFF *hTIFF, const char *pszPhotometric,
     VSIUnlink(osTmpFilenameIn);
 }
 
-/************************************************************************/
-/*                       PrepareTIFFErrorFormat()                       */
-/*                                                                      */
-/*      sometimes the "module" has stuff in it that has special         */
-/*      meaning in a printf() style format, so we try to escape it.     */
-/*      For now we hope the only thing we have to escape is %'s.        */
-/************************************************************************/
-
-static char *PrepareTIFFErrorFormat(const char *module, const char *fmt)
-
-{
-    const size_t nModuleSize = strlen(module);
-    const size_t nModFmtSize = nModuleSize * 2 + strlen(fmt) + 2;
-    char *pszModFmt = static_cast<char *>(CPLMalloc(nModFmtSize));
-
-    size_t iOut = 0;  // Used after for.
-
-    for (size_t iIn = 0; iIn < nModuleSize; ++iIn)
-    {
-        if (module[iIn] == '%')
-        {
-            CPLAssert(iOut < nModFmtSize - 2);
-            pszModFmt[iOut++] = '%';
-            pszModFmt[iOut++] = '%';
-        }
-        else
-        {
-            CPLAssert(iOut < nModFmtSize - 1);
-            pszModFmt[iOut++] = module[iIn];
-        }
-    }
-    CPLAssert(iOut < nModFmtSize);
-    pszModFmt[iOut] = '\0';
-    strcat(pszModFmt, ":");
-    strcat(pszModFmt, fmt);
-
-    return pszModFmt;
-}
-
 #if !defined(SUPPORTS_LIBTIFF_OPEN_OPTIONS)
 
 /************************************************************************/
@@ -817,7 +719,7 @@ static void GTiffWarningHandler(const char *module, const char *fmt, va_list ap)
     if (strstr(fmt, "nknown field") != nullptr)
         return;
 
-    char *pszModFmt = PrepareTIFFErrorFormat(module, fmt);
+    char *pszModFmt = gdal::tiff_common::PrepareTIFFErrorFormat(module, fmt);
     if (strstr(fmt, "does not end in null byte") != nullptr)
     {
         CPLString osMsg;
@@ -854,7 +756,7 @@ static void GTiffErrorHandler(const char *module, const char *fmt, va_list ap)
                   "Use BIGTIFF=YES creation option.";
     }
 
-    char *pszModFmt = PrepareTIFFErrorFormat(module, fmt);
+    char *pszModFmt = gdal::tiff_common::PrepareTIFFErrorFormat(module, fmt);
     CPLErrorV(CE_Failure, CPLE_AppDefined, pszModFmt, ap);
     CPLFree(pszModFmt);
     return;
@@ -886,7 +788,7 @@ int GTiffWarningHandlerExt(TIFF *tif, void *user_data, const char *module,
     if (strstr(fmt, "nknown field") != nullptr)
         return 1;
 
-    char *pszModFmt = PrepareTIFFErrorFormat(module, fmt);
+    char *pszModFmt = gdal::tiff_common::PrepareTIFFErrorFormat(module, fmt);
     if (strstr(fmt, "does not end in null byte") != nullptr)
     {
         CPLString osMsg;
@@ -932,7 +834,7 @@ int GTiffErrorHandlerExt(TIFF *tif, void *user_data, const char *module,
                   "Use BIGTIFF=YES creation option.";
     }
 
-    char *pszModFmt = PrepareTIFFErrorFormat(module, fmt);
+    char *pszModFmt = gdal::tiff_common::PrepareTIFFErrorFormat(module, fmt);
     CPLErrorV(CE_Failure, CPLE_AppDefined, pszModFmt, ap);
     CPLFree(pszModFmt);
     return 1;
diff --git a/frmts/gtiff/gtiffdataset_read.cpp b/frmts/gtiff/gtiffdataset_read.cpp
index 81c587b0f167..f845512741c3 100644
--- a/frmts/gtiff/gtiffdataset_read.cpp
+++ b/frmts/gtiff/gtiffdataset_read.cpp
@@ -43,6 +43,8 @@
 #include "tifvsi.h"
 #include "xtiffio.h"
 
+#include "tiff_common.h"
+
 /************************************************************************/
 /*                        GetJPEGOverviewCount()                        */
 /************************************************************************/
@@ -5219,88 +5221,10 @@ CPLErr GTiffDataset::OpenOffset(TIFF *hTIFFIn, toff_t nDirOffsetIn,
     }
     else
     {
-        m_poColorTable = std::make_unique<GDALColorTable>();
-
         const int nColorCount = 1 << m_nBitsPerSample;
-
-        if (m_nColorTableMultiplier == 0)
-        {
-            // TIFF color maps are in the [0, 65535] range, so some remapping must
-            // be done to get values in the [0, 255] range, but it is not clear
-            // how to do that exactly. Since GDAL 2.3.0 we have standardized on
-            // using a 257 multiplication factor (https://github.com/OSGeo/gdal/commit/eeec5b62e385d53e7f2edaba7b73c7c74bc2af39)
-            // but other software uses 256 (cf https://github.com/OSGeo/gdal/issues/10310)
-            // Do a first pass to check if all values are multiples of 256 or 257.
-            bool bFoundNonZeroEntry = false;
-            bool bAllValuesMultipleOf256 = true;
-            bool bAllValuesMultipleOf257 = true;
-            unsigned short nMaxColor = 0;
-            for (int iColor = 0; iColor < nColorCount; ++iColor)
-            {
-                if (panRed[iColor] > 0 || panGreen[iColor] > 0 ||
-                    panBlue[iColor] > 0)
-                {
-                    bFoundNonZeroEntry = true;
-                }
-                if ((panRed[iColor] % 256) != 0 ||
-                    (panGreen[iColor] % 256) != 0 ||
-                    (panBlue[iColor] % 256) != 0)
-                {
-                    bAllValuesMultipleOf256 = false;
-                }
-                if ((panRed[iColor] % 257) != 0 ||
-                    (panGreen[iColor] % 257) != 0 ||
-                    (panBlue[iColor] % 257) != 0)
-                {
-                    bAllValuesMultipleOf257 = false;
-                }
-
-                nMaxColor = std::max(nMaxColor, panRed[iColor]);
-                nMaxColor = std::max(nMaxColor, panGreen[iColor]);
-                nMaxColor = std::max(nMaxColor, panBlue[iColor]);
-            }
-
-            if (nMaxColor > 0 && nMaxColor < 256)
-            {
-                // Bug 1384 - Some TIFF files are generated with color map entry
-                // values in range 0-255 instead of 0-65535 - try to handle these
-                // gracefully.
-                m_nColorTableMultiplier = 1;
-                CPLDebug("GTiff",
-                         "TIFF ColorTable seems to be improperly scaled with "
-                         "values all in [0,255] range, fixing up.");
-            }
-            else
-            {
-                if (!bAllValuesMultipleOf256 && !bAllValuesMultipleOf257)
-                {
-                    CPLDebug("GTiff",
-                             "The color map contains entries which are not "
-                             "multiple of 256 or 257, so we don't know for "
-                             "sure how to remap them to [0, 255]. Default to "
-                             "using a 257 multiplication factor");
-                }
-                m_nColorTableMultiplier =
-                    (bFoundNonZeroEntry && bAllValuesMultipleOf256)
-                        ? 256
-                        : DEFAULT_COLOR_TABLE_MULTIPLIER_257;
-            }
-        }
-        CPLAssert(m_nColorTableMultiplier > 0);
-        CPLAssert(m_nColorTableMultiplier <= 257);
-        for (int iColor = nColorCount - 1; iColor >= 0; iColor--)
-        {
-            const GDALColorEntry oEntry = {
-                static_cast<short>(panRed[iColor] / m_nColorTableMultiplier),
-                static_cast<short>(panGreen[iColor] / m_nColorTableMultiplier),
-                static_cast<short>(panBlue[iColor] / m_nColorTableMultiplier),
-                static_cast<short>(
-                    m_bNoDataSet && static_cast<int>(m_dfNoDataValue) == iColor
-                        ? 0
-                        : 255)};
-
-            m_poColorTable->SetColorEntry(iColor, &oEntry);
-        }
+        m_poColorTable = gdal::tiff_common::TIFFColorMapTagToColorTable(
+            panRed, panGreen, panBlue, nColorCount, m_nColorTableMultiplier,
+            DEFAULT_COLOR_TABLE_MULTIPLIER_257, m_bNoDataSet, m_dfNoDataValue);
     }
 
     /* -------------------------------------------------------------------- */
diff --git a/frmts/libertiff/libertiffdataset.cpp b/frmts/libertiff/libertiffdataset.cpp
index bf8cbbf19603..9b4716805ab6 100644
--- a/frmts/libertiff/libertiffdataset.cpp
+++ b/frmts/libertiff/libertiffdataset.cpp
@@ -451,92 +451,16 @@ void LIBERTIFFBand::ReadColorMap()
             l_poDS->m_image->readTagAsVector<uint16_t>(*psTagColorMap, ok);
         if (colorMap.size() == psTagColorMap->count)
         {
-            m_poColorTable = std::make_unique<GDALColorTable>();
+            constexpr int DEFAULT_COLOR_TABLE_MULTIPLIER_257 = 257;
+            const int nColorCount = static_cast<int>(psTagColorMap->count) / 3;
+            const auto *panRed = colorMap.data();
+            const auto *panGreen = colorMap.data() + nColorCount;
+            const auto *panBlue = colorMap.data() + 2 * nColorCount;
+            int nColorTableMultiplier = 0;
+            m_poColorTable = gdal::tiff_common::TIFFColorMapTagToColorTable(
+                panRed, panGreen, panBlue, nColorCount, nColorTableMultiplier,
+                DEFAULT_COLOR_TABLE_MULTIPLIER_257, m_bHasNoData, m_dfNoData);
             m_eColorInterp = GCI_PaletteIndex;
-
-            // TIFF color maps are in the [0, 65535] range, so some remapping must
-            // be done to get values in the [0, 255] range, but it is not clear
-            // how to do that exactly. Since GDAL 2.3.0 we have standardized on
-            // using a 257 multiplication factor (https://github.com/OSGeo/gdal/commit/eeec5b62e385d53e7f2edaba7b73c7c74bc2af39)
-            // but other software uses 256 (cf https://github.com/OSGeo/gdal/issues/10310)
-            // Do a first pass to check if all values are multiples of 256 or 257.
-            bool bFoundNonZeroEntry = false;
-            bool bAllValuesMultipleOf256 = true;
-            bool bAllValuesMultipleOf257 = true;
-            unsigned short nMaxColor = 0;
-            int nColorCount = static_cast<int>(psTagColorMap->count / 3);
-            const auto panRed = colorMap.data();
-            const auto panGreen = colorMap.data() + nColorCount;
-            const auto panBlue = colorMap.data() + 2 * nColorCount;
-            for (int iColor = 0; iColor < nColorCount; ++iColor)
-            {
-                if (panRed[iColor] > 0 || panGreen[iColor] > 0 ||
-                    panBlue[iColor] > 0)
-                {
-                    bFoundNonZeroEntry = true;
-                }
-                if ((panRed[iColor] % 256) != 0 ||
-                    (panGreen[iColor] % 256) != 0 ||
-                    (panBlue[iColor] % 256) != 0)
-                {
-                    bAllValuesMultipleOf256 = false;
-                }
-                if ((panRed[iColor] % 257) != 0 ||
-                    (panGreen[iColor] % 257) != 0 ||
-                    (panBlue[iColor] % 257) != 0)
-                {
-                    bAllValuesMultipleOf257 = false;
-                }
-
-                nMaxColor = std::max(nMaxColor, panRed[iColor]);
-                nMaxColor = std::max(nMaxColor, panGreen[iColor]);
-                nMaxColor = std::max(nMaxColor, panBlue[iColor]);
-            }
-
-            int nColorTableMultiplier;
-            if (nMaxColor > 0 && nMaxColor < 256)
-            {
-                // Bug 1384 - Some TIFF files are generated with color map entry
-                // values in range 0-255 instead of 0-65535 - try to handle these
-                // gracefully.
-                nColorTableMultiplier = 1;
-                CPLDebug("GTiff",
-                         "TIFF ColorTable seems to be improperly scaled with "
-                         "values all in [0,255] range, fixing up.");
-            }
-            else
-            {
-                if (!bAllValuesMultipleOf256 && !bAllValuesMultipleOf257)
-                {
-                    CPLDebug("GTiff",
-                             "The color map contains entries which are not "
-                             "multiple of 256 or 257, so we don't know for "
-                             "sure how to remap them to [0, 255]. Default to "
-                             "using a 257 multiplication factor");
-                }
-                constexpr int DEFAULT_COLOR_TABLE_MULTIPLIER_257 = 257;
-                nColorTableMultiplier =
-                    (bFoundNonZeroEntry && bAllValuesMultipleOf256)
-                        ? 256
-                        : DEFAULT_COLOR_TABLE_MULTIPLIER_257;
-            }
-
-            CPLAssert(nColorTableMultiplier > 0);
-            CPLAssert(nColorTableMultiplier <= 257);
-            for (int iColor = nColorCount - 1; iColor >= 0; iColor--)
-            {
-                const GDALColorEntry oEntry = {
-                    static_cast<short>(panRed[iColor] / nColorTableMultiplier),
-                    static_cast<short>(panGreen[iColor] /
-                                       nColorTableMultiplier),
-                    static_cast<short>(panBlue[iColor] / nColorTableMultiplier),
-                    static_cast<short>(
-                        m_bHasNoData && static_cast<int>(m_dfNoData) == iColor
-                            ? 0
-                            : 255)};
-
-                m_poColorTable->SetColorEntry(iColor, &oEntry);
-            }
         }
     }
 }
@@ -3249,69 +3173,10 @@ void LIBERTIFFDataset::ReadRPCTag()
             m_image->readTagAsVector<double>(*psTagRPCCoefficients, ok);
         if (ok && adfRPC.size() == 92)
         {
-            CPLStringList asMD;
-            asMD.SetNameValue(RPC_ERR_BIAS, CPLOPrintf("%.15g", adfRPC[0]));
-            asMD.SetNameValue(RPC_ERR_RAND, CPLOPrintf("%.15g", adfRPC[1]));
-            asMD.SetNameValue(RPC_LINE_OFF, CPLOPrintf("%.15g", adfRPC[2]));
-            asMD.SetNameValue(RPC_SAMP_OFF, CPLOPrintf("%.15g", adfRPC[3]));
-            asMD.SetNameValue(RPC_LAT_OFF, CPLOPrintf("%.15g", adfRPC[4]));
-            asMD.SetNameValue(RPC_LONG_OFF, CPLOPrintf("%.15g", adfRPC[5]));
-            asMD.SetNameValue(RPC_HEIGHT_OFF, CPLOPrintf("%.15g", adfRPC[6]));
-            asMD.SetNameValue(RPC_LINE_SCALE, CPLOPrintf("%.15g", adfRPC[7]));
-            asMD.SetNameValue(RPC_SAMP_SCALE, CPLOPrintf("%.15g", adfRPC[8]));
-            asMD.SetNameValue(RPC_LAT_SCALE, CPLOPrintf("%.15g", adfRPC[9]));
-            asMD.SetNameValue(RPC_LONG_SCALE, CPLOPrintf("%.15g", adfRPC[10]));
-            asMD.SetNameValue(RPC_HEIGHT_SCALE,
-                              CPLOPrintf("%.15g", adfRPC[11]));
-
-            CPLString osField;
-            CPLString osMultiField;
-
-            for (int i = 0; i < 20; ++i)
-            {
-                osField.Printf("%.15g", adfRPC[12 + i]);
-                if (i > 0)
-                    osMultiField += " ";
-                else
-                    osMultiField = "";
-                osMultiField += osField;
-            }
-            asMD.SetNameValue(RPC_LINE_NUM_COEFF, osMultiField);
-
-            for (int i = 0; i < 20; ++i)
-            {
-                osField.Printf("%.15g", adfRPC[32 + i]);
-                if (i > 0)
-                    osMultiField += " ";
-                else
-                    osMultiField = "";
-                osMultiField += osField;
-            }
-            asMD.SetNameValue(RPC_LINE_DEN_COEFF, osMultiField);
-
-            for (int i = 0; i < 20; ++i)
-            {
-                osField.Printf("%.15g", adfRPC[52 + i]);
-                if (i > 0)
-                    osMultiField += " ";
-                else
-                    osMultiField = "";
-                osMultiField += osField;
-            }
-            asMD.SetNameValue(RPC_SAMP_NUM_COEFF, osMultiField);
-
-            for (int i = 0; i < 20; ++i)
-            {
-                osField.Printf("%.15g", adfRPC[72 + i]);
-                if (i > 0)
-                    osMultiField += " ";
-                else
-                    osMultiField = "";
-                osMultiField += osField;
-            }
-            asMD.SetNameValue(RPC_SAMP_DEN_COEFF, osMultiField);
-
-            GDALDataset::SetMetadata(asMD.List(), "RPC");
+            GDALDataset::SetMetadata(
+                gdal::tiff_common::TIFFRPCTagToRPCMetadata(adfRPC.data())
+                    .List(),
+                "RPC");
         }
     }
 }
diff --git a/frmts/libertiff/libtiff_codecs.h b/frmts/libertiff/libtiff_codecs.h
index 60fd454f0e25..08f81c529896 100644
--- a/frmts/libertiff/libtiff_codecs.h
+++ b/frmts/libertiff/libtiff_codecs.h
@@ -10,6 +10,8 @@
  * SPDX-License-Identifier: MIT
  ****************************************************************************/
 
+#include "tiff_common.h"
+
 // Use code from internal libtiff for LZW, PackBits and LERC codecs
 #define TIFFInitLZW LIBERTIFF_TIFFInitLZW
 #define TIFFInitPackBits LIBERTIFF_TIFFInitPackBits
@@ -116,49 +118,11 @@ extern "C"
         return 0;
     }
 
-    /************************************************************************/
-    /*                       PrepareTIFFErrorFormat()                       */
-    /*                                                                      */
-    /*      sometimes the "module" has stuff in it that has special         */
-    /*      meaning in a printf() style format, so we try to escape it.     */
-    /*      For now we hope the only thing we have to escape is %'s.        */
-    /************************************************************************/
-
-    static char *PrepareTIFFErrorFormat(const char *module, const char *fmt)
-
-    {
-        const size_t nModuleSize = strlen(module);
-        const size_t nModFmtSize = nModuleSize * 2 + strlen(fmt) + 2;
-        char *pszModFmt = static_cast<char *>(CPLMalloc(nModFmtSize));
-
-        size_t iOut = 0;  // Used after for.
-
-        for (size_t iIn = 0; iIn < nModuleSize; ++iIn)
-        {
-            if (module[iIn] == '%')
-            {
-                CPLAssert(iOut < nModFmtSize - 2);
-                pszModFmt[iOut++] = '%';
-                pszModFmt[iOut++] = '%';
-            }
-            else
-            {
-                CPLAssert(iOut < nModFmtSize - 1);
-                pszModFmt[iOut++] = module[iIn];
-            }
-        }
-        CPLAssert(iOut < nModFmtSize);
-        pszModFmt[iOut] = '\0';
-        strcat(pszModFmt, ":");
-        strcat(pszModFmt, fmt);
-
-        return pszModFmt;
-    }
-
     void LIBERTIFF_TIFFWarningExtR(TIFF *, const char *pszModule,
                                    const char *fmt, ...)
     {
-        char *pszModFmt = PrepareTIFFErrorFormat(pszModule, fmt);
+        char *pszModFmt =
+            gdal::tiff_common::PrepareTIFFErrorFormat(pszModule, fmt);
         va_list ap;
         va_start(ap, fmt);
         CPLErrorV(CE_Warning, CPLE_AppDefined, pszModFmt, ap);
@@ -169,7 +133,8 @@ extern "C"
     void LIBERTIFF_TIFFErrorExtR(TIFF *, const char *pszModule, const char *fmt,
                                  ...)
     {
-        char *pszModFmt = PrepareTIFFErrorFormat(pszModule, fmt);
+        char *pszModFmt =
+            gdal::tiff_common::PrepareTIFFErrorFormat(pszModule, fmt);
         va_list ap;
         va_start(ap, fmt);
         CPLErrorV(CE_Failure, CPLE_AppDefined, pszModFmt, ap);
diff --git a/gcore/CMakeLists.txt b/gcore/CMakeLists.txt
index 58f226aecb3f..044a4c667196 100644
--- a/gcore/CMakeLists.txt
+++ b/gcore/CMakeLists.txt
@@ -58,7 +58,9 @@ add_library(
   gdalpythondriverloader.cpp
   tilematrixset.cpp
   gdal_thread_pool.cpp
-  nasakeywordhandler.cpp)
+  nasakeywordhandler.cpp
+  tiff_common.cpp
+)
 
 add_library(gcore_gdal_misc OBJECT gdal_misc.cpp)
 gdal_standard_includes(gcore_gdal_misc)
diff --git a/gcore/tiff_common.cpp b/gcore/tiff_common.cpp
new file mode 100644
index 000000000000..2a5644de9337
--- /dev/null
+++ b/gcore/tiff_common.cpp
@@ -0,0 +1,223 @@
+/******************************************************************************
+ *
+ * Project:  GDAL Core
+ * Purpose:  Common code shared between the GTiff and libertiff drivers
+ * Author:   Even Rouault <even dot rouault at spatialys.com>
+ *
+ ******************************************************************************
+ * Copyright (c) 2024, Even Rouault <even dot rouault at spatialys.com>
+ *
+ * SPDX-License-Identifier: MIT
+ ****************************************************************************/
+
+#include "tiff_common.h"
+
+#include <algorithm>
+
+#include "gdal_mdreader.h"
+
+namespace gdal
+{
+namespace tiff_common
+{
+
+/************************************************************************/
+/*                       PrepareTIFFErrorFormat()                       */
+/*                                                                      */
+/*      sometimes the "module" has stuff in it that has special         */
+/*      meaning in a printf() style format, so we try to escape it.     */
+/*      For now we hope the only thing we have to escape is %'s.        */
+/************************************************************************/
+
+char *PrepareTIFFErrorFormat(const char *module, const char *fmt)
+
+{
+    const size_t nModuleSize = strlen(module);
+    const size_t nModFmtSize = nModuleSize * 2 + strlen(fmt) + 2;
+    char *pszModFmt = static_cast<char *>(CPLMalloc(nModFmtSize));
+
+    size_t iOut = 0;  // Used after for.
+
+    for (size_t iIn = 0; iIn < nModuleSize; ++iIn)
+    {
+        if (module[iIn] == '%')
+        {
+            CPLAssert(iOut < nModFmtSize - 2);
+            pszModFmt[iOut++] = '%';
+            pszModFmt[iOut++] = '%';
+        }
+        else
+        {
+            CPLAssert(iOut < nModFmtSize - 1);
+            pszModFmt[iOut++] = module[iIn];
+        }
+    }
+    CPLAssert(iOut < nModFmtSize);
+    pszModFmt[iOut] = '\0';
+    strcat(pszModFmt, ":");
+    strcat(pszModFmt, fmt);
+
+    return pszModFmt;
+}
+
+/************************************************************************/
+/*                     TIFFColorMapTagToColorTable()                    */
+/************************************************************************/
+
+std::unique_ptr<GDALColorTable> TIFFColorMapTagToColorTable(
+    const unsigned short *panRed, const unsigned short *panGreen,
+    const unsigned short *panBlue, int nColorCount, int &nColorTableMultiplier,
+    int nDefaultColorTableMultiplier, bool bNoDataSet, double dfNoDataValue)
+{
+    auto poColorTable = std::make_unique<GDALColorTable>();
+
+    if (nColorTableMultiplier == 0)
+    {
+        // TIFF color maps are in the [0, 65535] range, so some remapping must
+        // be done to get values in the [0, 255] range, but it is not clear
+        // how to do that exactly. Since GDAL 2.3.0 we have standardized on
+        // using a 257 multiplication factor (https://github.com/OSGeo/gdal/commit/eeec5b62e385d53e7f2edaba7b73c7c74bc2af39)
+        // but other software uses 256 (cf https://github.com/OSGeo/gdal/issues/10310)
+        // Do a first pass to check if all values are multiples of 256 or 257.
+        bool bFoundNonZeroEntry = false;
+        bool bAllValuesMultipleOf256 = true;
+        bool bAllValuesMultipleOf257 = true;
+        unsigned short nMaxColor = 0;
+        for (int iColor = 0; iColor < nColorCount; ++iColor)
+        {
+            if (panRed[iColor] > 0 || panGreen[iColor] > 0 ||
+                panBlue[iColor] > 0)
+            {
+                bFoundNonZeroEntry = true;
+            }
+            if ((panRed[iColor] % 256) != 0 || (panGreen[iColor] % 256) != 0 ||
+                (panBlue[iColor] % 256) != 0)
+            {
+                bAllValuesMultipleOf256 = false;
+            }
+            if ((panRed[iColor] % 257) != 0 || (panGreen[iColor] % 257) != 0 ||
+                (panBlue[iColor] % 257) != 0)
+            {
+                bAllValuesMultipleOf257 = false;
+            }
+
+            nMaxColor = std::max(nMaxColor, panRed[iColor]);
+            nMaxColor = std::max(nMaxColor, panGreen[iColor]);
+            nMaxColor = std::max(nMaxColor, panBlue[iColor]);
+        }
+
+        if (nMaxColor > 0 && nMaxColor < 256)
+        {
+            // Bug 1384 - Some TIFF files are generated with color map entry
+            // values in range 0-255 instead of 0-65535 - try to handle these
+            // gracefully.
+            nColorTableMultiplier = 1;
+            CPLDebug("GTiff",
+                     "TIFF ColorTable seems to be improperly scaled with "
+                     "values all in [0,255] range, fixing up.");
+        }
+        else
+        {
+            if (!bAllValuesMultipleOf256 && !bAllValuesMultipleOf257)
+            {
+                CPLDebug("GTiff",
+                         "The color map contains entries which are not "
+                         "multiple of 256 or 257, so we don't know for "
+                         "sure how to remap them to [0, 255]. Default to "
+                         "using a 257 multiplication factor");
+            }
+            nColorTableMultiplier =
+                (bFoundNonZeroEntry && bAllValuesMultipleOf256)
+                    ? 256
+                    : nDefaultColorTableMultiplier;
+        }
+    }
+    CPLAssert(nColorTableMultiplier > 0);
+    CPLAssert(nColorTableMultiplier <= 257);
+    for (int iColor = nColorCount - 1; iColor >= 0; iColor--)
+    {
+        const GDALColorEntry oEntry = {
+            static_cast<short>(panRed[iColor] / nColorTableMultiplier),
+            static_cast<short>(panGreen[iColor] / nColorTableMultiplier),
+            static_cast<short>(panBlue[iColor] / nColorTableMultiplier),
+            static_cast<short>(
+                bNoDataSet && static_cast<int>(dfNoDataValue) == iColor ? 0
+                                                                        : 255)};
+
+        poColorTable->SetColorEntry(iColor, &oEntry);
+    }
+
+    return poColorTable;
+}
+
+/************************************************************************/
+/*                      TIFFRPCTagToRPCMetadata()                       */
+/************************************************************************/
+
+CPLStringList TIFFRPCTagToRPCMetadata(const double adfRPC[92])
+{
+    CPLStringList asMD;
+    asMD.SetNameValue(RPC_ERR_BIAS, CPLOPrintf("%.15g", adfRPC[0]));
+    asMD.SetNameValue(RPC_ERR_RAND, CPLOPrintf("%.15g", adfRPC[1]));
+    asMD.SetNameValue(RPC_LINE_OFF, CPLOPrintf("%.15g", adfRPC[2]));
+    asMD.SetNameValue(RPC_SAMP_OFF, CPLOPrintf("%.15g", adfRPC[3]));
+    asMD.SetNameValue(RPC_LAT_OFF, CPLOPrintf("%.15g", adfRPC[4]));
+    asMD.SetNameValue(RPC_LONG_OFF, CPLOPrintf("%.15g", adfRPC[5]));
+    asMD.SetNameValue(RPC_HEIGHT_OFF, CPLOPrintf("%.15g", adfRPC[6]));
+    asMD.SetNameValue(RPC_LINE_SCALE, CPLOPrintf("%.15g", adfRPC[7]));
+    asMD.SetNameValue(RPC_SAMP_SCALE, CPLOPrintf("%.15g", adfRPC[8]));
+    asMD.SetNameValue(RPC_LAT_SCALE, CPLOPrintf("%.15g", adfRPC[9]));
+    asMD.SetNameValue(RPC_LONG_SCALE, CPLOPrintf("%.15g", adfRPC[10]));
+    asMD.SetNameValue(RPC_HEIGHT_SCALE, CPLOPrintf("%.15g", adfRPC[11]));
+
+    CPLString osField;
+    CPLString osMultiField;
+
+    for (int i = 0; i < 20; ++i)
+    {
+        osField.Printf("%.15g", adfRPC[12 + i]);
+        if (i > 0)
+            osMultiField += " ";
+        else
+            osMultiField = "";
+        osMultiField += osField;
+    }
+    asMD.SetNameValue(RPC_LINE_NUM_COEFF, osMultiField);
+
+    for (int i = 0; i < 20; ++i)
+    {
+        osField.Printf("%.15g", adfRPC[32 + i]);
+        if (i > 0)
+            osMultiField += " ";
+        else
+            osMultiField = "";
+        osMultiField += osField;
+    }
+    asMD.SetNameValue(RPC_LINE_DEN_COEFF, osMultiField);
+
+    for (int i = 0; i < 20; ++i)
+    {
+        osField.Printf("%.15g", adfRPC[52 + i]);
+        if (i > 0)
+            osMultiField += " ";
+        else
+            osMultiField = "";
+        osMultiField += osField;
+    }
+    asMD.SetNameValue(RPC_SAMP_NUM_COEFF, osMultiField);
+
+    for (int i = 0; i < 20; ++i)
+    {
+        osField.Printf("%.15g", adfRPC[72 + i]);
+        if (i > 0)
+            osMultiField += " ";
+        else
+            osMultiField = "";
+        osMultiField += osField;
+    }
+    asMD.SetNameValue(RPC_SAMP_DEN_COEFF, osMultiField);
+    return asMD;
+}
+
+}  // namespace tiff_common
+}  // namespace gdal
diff --git a/gcore/tiff_common.h b/gcore/tiff_common.h
new file mode 100644
index 000000000000..9c3ba6d152a9
--- /dev/null
+++ b/gcore/tiff_common.h
@@ -0,0 +1,36 @@
+/******************************************************************************
+ *
+ * Project:  GDAL Core
+ * Purpose:  Common code shared between the GTiff and libertiff drivers
+ * Author:   Even Rouault <even dot rouault at spatialys.com>
+ *
+ ******************************************************************************
+ * Copyright (c) 2024, Even Rouault <even dot rouault at spatialys.com>
+ *
+ * SPDX-License-Identifier: MIT
+ ****************************************************************************/
+
+#ifndef TIFF_COMMON_HPP
+#define TIFF_COMMON_HPP
+
+#include "cpl_string.h"
+
+#include "gdal_priv.h"
+
+namespace gdal
+{
+namespace tiff_common
+{
+char CPL_DLL *PrepareTIFFErrorFormat(const char *module, const char *fmt);
+
+std::unique_ptr<GDALColorTable> CPL_DLL TIFFColorMapTagToColorTable(
+    const unsigned short *panRed, const unsigned short *panGreen,
+    const unsigned short *panBlue, int nColorCount, int &nColorTableMultiplier,
+    int nDefaultColorTableMultiplier, bool bNoDataSet, double dfNoDataValue);
+
+CPLStringList CPL_DLL TIFFRPCTagToRPCMetadata(const double adfRPC[92]);
+
+}  // namespace tiff_common
+}  // namespace gdal
+
+#endif

From 13f91a81c99dabbedd76848f3c2db01215388329 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Sun, 22 Dec 2024 18:46:31 +0100
Subject: [PATCH 07/40] CI: update ASAN to Ubuntu 24.04

---
 .github/workflows/asan/test.sh    | 4 ++--
 .github/workflows/linux_build.yml | 6 +++---
 autotest/lsan_suppressions.txt    | 2 ++
 3 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/asan/test.sh b/.github/workflows/asan/test.sh
index b51a96ef8fcc..acf8a6576fd7 100755
--- a/.github/workflows/asan/test.sh
+++ b/.github/workflows/asan/test.sh
@@ -4,8 +4,8 @@ set -ex
 
 . ../scripts/setdevenv.sh
 
-export LD_LIBRARY_PATH=/usr/lib/llvm-14/lib/clang/14.0.0/lib/linux:${LD_LIBRARY_PATH}
-export PATH=/usr/lib/llvm-14/bin:${PATH}
+export LD_LIBRARY_PATH=/usr/lib/llvm-18/lib/clang/18.0.0/lib/linux:${LD_LIBRARY_PATH}
+export PATH=/usr/lib/llvm-18/bin:${PATH}
 export SKIP_MEM_INTENSIVE_TEST=YES
 export SKIP_VIRTUALMEM=YES
 export LD_PRELOAD=$(clang -print-file-name=libclang_rt.asan-x86_64.so)
diff --git a/.github/workflows/linux_build.yml b/.github/workflows/linux_build.yml
index 8f6e304f5c2e..1b760a86231e 100644
--- a/.github/workflows/linux_build.yml
+++ b/.github/workflows/linux_build.yml
@@ -100,13 +100,13 @@ jobs:
             test_script: test.sh
             os: ubuntu-22.04
 
-          - name: Ubuntu 22.04, clang ASAN
+          - name: Ubuntu 24.04, clang ASAN
             id: asan
             travis_branch: sanitize
-            container: ubuntu_22.04
+            container: ubuntu_24.04
             build_script: build.sh
             test_script: test.sh
-            os: ubuntu-22.04
+            os: ubuntu-24.04
 
           - name: Ubuntu 20.04, gcc
             id: ubuntu_20.04
diff --git a/autotest/lsan_suppressions.txt b/autotest/lsan_suppressions.txt
index 9c3329c37dbd..e4547caf428f 100644
--- a/autotest/lsan_suppressions.txt
+++ b/autotest/lsan_suppressions.txt
@@ -12,3 +12,5 @@ leak:PyDataMem_NEW
 leak:PyArray_NewFromDescr_int
 leak:/usr/bin/python3.8
 leak:/usr/bin/python3.10
+leak:/usr/bin/python3.12
+leak:/lib/x86_64-linux-gnu/libduckdb.so

From db9a52aafd01872544460d874ea488a783deadc9 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Tue, 24 Dec 2024 13:04:24 +0100
Subject: [PATCH 08/40] LIBERTIFF: add NUM_THREADS open option to allow for
 multithreaded decompression when RasterIO() requests intersect several tiles

---
 autotest/gcore/libertiff.py             |  19 ++++-
 doc/source/drivers/raster/libertiff.rst |  14 +++
 frmts/libertiff/libertiffdataset.cpp    | 109 +++++++++++++++++++-----
 port/cpl_known_config_options.h         |   2 +-
 4 files changed, 119 insertions(+), 25 deletions(-)

diff --git a/autotest/gcore/libertiff.py b/autotest/gcore/libertiff.py
index 3b5c09da92c4..6d8b535dfcd0 100755
--- a/autotest/gcore/libertiff.py
+++ b/autotest/gcore/libertiff.py
@@ -24,8 +24,10 @@
 pytestmark = pytest.mark.require_driver("LIBERTIFF")
 
 
-def libertiff_open(filename):
-    return gdal.OpenEx(filename, allowed_drivers=["LIBERTIFF"])
+def libertiff_open(filename, open_options=[]):
+    return gdal.OpenEx(
+        filename, allowed_drivers=["LIBERTIFF"], open_options=open_options
+    )
 
 
 def test_libertiff_basic():
@@ -337,7 +339,8 @@ def test_libertiff_check_byte(filename_middle):
         "int16_bigendian_lzw_predictor_2",
     ],
 )
-def test_libertiff_check_rgbsmall(filename_middle):
+@pytest.mark.parametrize("NUM_THREADS", [None, "2", "ALL_CPUS"])
+def test_libertiff_check_rgbsmall(filename_middle, NUM_THREADS):
     if "JPEG" in filename_middle and gdal.GetDriverByName("JPEG") is None:
         pytest.skip("JPEG driver missing")
     if "JXL" in filename_middle and gdal.GetDriverByName("JPEGXL") is None:
@@ -369,7 +372,10 @@ def test_libertiff_check_rgbsmall(filename_middle):
     ):
         pytest.skip("ZSTD support missing")
 
-    ds = libertiff_open(f"data/gtiff/rgbsmall_{filename_middle}.tif")
+    ds = libertiff_open(
+        f"data/gtiff/rgbsmall_{filename_middle}.tif",
+        open_options=([] if NUM_THREADS is None else ["NUM_THREADS=" + NUM_THREADS]),
+    )
     if "JPEG" in filename_middle:
         assert ds.GetRasterBand(1).Checksum() > 0
         if gdal.GetDriverByName("GTiff"):
@@ -848,3 +854,8 @@ def test_libertiff_read_geomatrix():
 
     ds = libertiff_open("data/geomatrix.tif")
     assert ds.GetGeoTransform() == (1841001.75, 1.5, -5.0, 1144003.25, -5.0, -1.5)
+
+
+def test_libertiff_num_threads_saturated():
+
+    libertiff_open("data/byte.tif", open_options=["NUM_THREADS=10000"])
diff --git a/doc/source/drivers/raster/libertiff.rst b/doc/source/drivers/raster/libertiff.rst
index 89d6b9b472d9..b13ab47c4a50 100644
--- a/doc/source/drivers/raster/libertiff.rst
+++ b/doc/source/drivers/raster/libertiff.rst
@@ -34,3 +34,17 @@ Driver capabilities
 .. supports_georeferencing::
 
 .. supports_virtualio::
+
+Open options
+------------
+
+|about-open-options|
+This driver supports the following open options:
+
+.. oo:: NUM_THREADS
+   :choices: <number_of_threads>, ALL_CPUS
+
+   This option also enables multi-threaded decoding
+   when RasterIO() requests intersect several tiles/strips.
+   The :config:`GDAL_NUM_THREADS` configuration option can also
+   be used as an alternative to setting the open option.
diff --git a/frmts/libertiff/libertiffdataset.cpp b/frmts/libertiff/libertiffdataset.cpp
index 9b4716805ab6..e9bcf7b75cd7 100644
--- a/frmts/libertiff/libertiffdataset.cpp
+++ b/frmts/libertiff/libertiffdataset.cpp
@@ -14,9 +14,12 @@
 #include "cpl_mem_cache.h"
 #include "cpl_minixml.h"
 #include "cpl_vsi_virtual.h"
+#include "cpl_multiproc.h"           // CPLGetNumCPUs()
+#include "cpl_worker_thread_pool.h"  // CPLJobQueue, CPLWorkerThreadPool
 
 #include <algorithm>
 #include <array>
+#include <atomic>
 #include <limits>
 #include <map>
 #include <mutex>
@@ -25,6 +28,7 @@
 #include "gdal_pam.h"
 #include "gdal_mdreader.h"
 #include "gdal_interpolateatpoint.h"
+#include "gdal_thread_pool.h"
 #include "memdataset.h"
 
 #define LIBERTIFF_NS GDALLibertiffDataset
@@ -175,6 +179,7 @@ class LIBERTIFFDataset final : public GDALPamDataset
     int m_lercVersion = LERC_VERSION_2_4;
     int m_lercAdditionalCompression = LERC_ADD_COMPRESSION_NONE;
     std::vector<uint16_t> m_extraSamples{};
+    CPLWorkerThreadPool *m_poThreadPool = nullptr;
 
     struct ThreadLocalState
     {
@@ -867,45 +872,86 @@ CPLErr LIBERTIFFDataset::IRasterIO(
     const int iYBlockMax = DIV_ROUND_UP(nYOff + nBufYSize, nBlockYSize);
     const int iXBlockMax = DIV_ROUND_UP(nXOff + nBufXSize, nBlockXSize);
 
-    // Could be parallelized
-    for (int iYBlock = iYBlockMin, iY = 0; iYBlock < iYBlockMax;
+    CPLJobQueuePtr poQueue;
+    const bool bIsSeparate = m_image->planarConfiguration() ==
+                             LIBERTIFF_NS::PlanarConfiguration::Separate;
+    if (m_poThreadPool &&
+        (iYBlockMax - iYBlockMin > 1 || iXBlockMax - iXBlockMin > 1 ||
+         (bIsSeparate && nBandCount > 1)))
+    {
+        poQueue = m_poThreadPool->CreateJobQueue();
+    }
+    std::atomic<bool> bSuccess(true);
+
+    for (int iYBlock = iYBlockMin, iY = 0; iYBlock < iYBlockMax && bSuccess;
          ++iYBlock, ++iY)
     {
-        for (int iXBlock = iXBlockMin, iX = 0; iXBlock < iXBlockMax;
+        for (int iXBlock = iXBlockMin, iX = 0; iXBlock < iXBlockMax && bSuccess;
              ++iXBlock, ++iX)
         {
-            if (m_image->planarConfiguration() ==
-                LIBERTIFF_NS::PlanarConfiguration::Separate)
+            if (bIsSeparate)
             {
                 for (int iBand = 0; iBand < nBandCount; ++iBand)
                 {
-                    int anBand[] = {panBandMap[iBand]};
-                    if (!ReadBlock(static_cast<GByte *>(pData) +
-                                       iY * nLineSpace * nBlockYSize +
-                                       iX * nPixelSpace * nBlockXSize +
-                                       iBand * nBandSpace,
-                                   iXBlock, iYBlock, 1, anBand, eBufType,
-                                   nPixelSpace, nLineSpace, nBandSpace))
+                    const auto lambda = [this, &bSuccess, iBand, panBandMap,
+                                         pData, iY, nLineSpace, nBlockYSize, iX,
+                                         nPixelSpace, nBlockXSize, nBandSpace,
+                                         iXBlock, iYBlock, eBufType]()
                     {
-                        return CE_Failure;
+                        int anBand[] = {panBandMap[iBand]};
+                        if (!ReadBlock(static_cast<GByte *>(pData) +
+                                           iY * nLineSpace * nBlockYSize +
+                                           iX * nPixelSpace * nBlockXSize +
+                                           iBand * nBandSpace,
+                                       iXBlock, iYBlock, 1, anBand, eBufType,
+                                       nPixelSpace, nLineSpace, nBandSpace))
+                        {
+                            bSuccess = false;
+                        }
+                    };
+                    if (poQueue)
+                    {
+                        poQueue->SubmitJob(lambda);
+                    }
+                    else
+                    {
+                        lambda();
                     }
                 }
             }
             else
             {
-                if (!ReadBlock(static_cast<GByte *>(pData) +
-                                   iY * nLineSpace * nBlockYSize +
-                                   iX * nPixelSpace * nBlockXSize,
-                               iXBlock, iYBlock, nBandCount, panBandMap,
-                               eBufType, nPixelSpace, nLineSpace, nBandSpace))
+                const auto lambda = [this, &bSuccess, nBandCount, panBandMap,
+                                     pData, iY, nLineSpace, nBlockYSize, iX,
+                                     nPixelSpace, nBlockXSize, nBandSpace,
+                                     iXBlock, iYBlock, eBufType]()
                 {
-                    return CE_Failure;
+                    if (!ReadBlock(static_cast<GByte *>(pData) +
+                                       iY * nLineSpace * nBlockYSize +
+                                       iX * nPixelSpace * nBlockXSize,
+                                   iXBlock, iYBlock, nBandCount, panBandMap,
+                                   eBufType, nPixelSpace, nLineSpace,
+                                   nBandSpace))
+                    {
+                        bSuccess = false;
+                    }
+                };
+                if (poQueue)
+                {
+                    poQueue->SubmitJob(lambda);
+                }
+                else
+                {
+                    lambda();
                 }
             }
         }
     }
 
-    return CE_None;
+    if (poQueue)
+        poQueue->WaitCompletion();
+
+    return bSuccess ? CE_None : CE_Failure;
 }
 
 /************************************************************************/
@@ -2862,6 +2908,22 @@ bool LIBERTIFFDataset::Open(GDALOpenInfo *poOpenInfo)
         poOpenInfo->fpL = nullptr;
     }
 
+    const char *pszValue =
+        CSLFetchNameValue(poOpenInfo->papszOpenOptions, "NUM_THREADS");
+    if (pszValue == nullptr)
+        pszValue = CPLGetConfigOption("GDAL_NUM_THREADS", nullptr);
+    if (pszValue)
+    {
+        int nThreads =
+            EQUAL(pszValue, "ALL_CPUS") ? CPLGetNumCPUs() : atoi(pszValue);
+        if (nThreads > 1024)
+            nThreads = 1024;  // to please Coverity
+        if (nThreads > 1)
+        {
+            m_poThreadPool = GDALGetGlobalThreadPool(nThreads);
+        }
+    }
+
     return true;
 }
 
@@ -3221,6 +3283,13 @@ void GDALRegister_LIBERTIFF()
     poDriver->pfnIdentify = LIBERTIFFDataset::Identify;
     poDriver->pfnOpen = LIBERTIFFDataset::OpenStatic;
 
+    poDriver->SetMetadataItem(
+        GDAL_DMD_OPENOPTIONLIST,
+        "<OpenOptionList>"
+        "   <Option name='NUM_THREADS' type='string' description='Number of "
+        "worker threads for compression. Can be set to ALL_CPUS' default='1'/>"
+        "</OpenOptionList>");
+
     if (CPLGetDecompressor("lzma"))
     {
         poDriver->SetMetadataItem("LZMA_SUPPORT", "YES", "LIBERTIFF");
diff --git a/port/cpl_known_config_options.h b/port/cpl_known_config_options.h
index 3d57944c2ce5..ade4a4146762 100644
--- a/port/cpl_known_config_options.h
+++ b/port/cpl_known_config_options.h
@@ -334,7 +334,7 @@ constexpr static const char* const apszKnownConfigOptions[] =
    "GDAL_NETCDF_REPORT_EXTRA_DIM_VALUES", // from netcdfdataset.cpp
    "GDAL_NETCDF_VERIFY_DIMS", // from netcdfdataset.cpp
    "GDAL_NO_COSTLY_OVERVIEW", // from rasterio.cpp
-   "GDAL_NUM_THREADS", // from avifdataset.cpp, common.cpp, cpl_vsil_gzip.cpp, gdal_tps.cpp, gdalgrid.cpp, gdalpansharpen.cpp, gdaltileindexdataset.cpp, gdalwarpkernel.cpp, gtiffdataset_write.cpp, jpegxl.cpp, ogr2ogr_lib.cpp, ogrmvtdataset.cpp, ogrparquetlayer.cpp, osm_parser.cpp, overview.cpp, rmfdataset.cpp, vrtdataset.cpp, zarr_array.cpp
+   "GDAL_NUM_THREADS", // from avifdataset.cpp, common.cpp, cpl_vsil_gzip.cpp, gdal_tps.cpp, gdalgrid.cpp, gdalpansharpen.cpp, gdaltileindexdataset.cpp, gdalwarpkernel.cpp, gtiffdataset_write.cpp, jpegxl.cpp, libertiffdataset.cpp, ogr2ogr_lib.cpp, ogrmvtdataset.cpp, ogrparquetlayer.cpp, osm_parser.cpp, overview.cpp, rmfdataset.cpp, vrtdataset.cpp, zarr_array.cpp
    "GDAL_OGCAPI_TILEMATRIXSET_LIMITS", // from gdalogcapidataset.cpp
    "GDAL_ONE_BIG_READ", // from jp2kakdataset.cpp, jpipkakdataset.cpp, mrsiddataset.cpp, rawdataset.cpp, wcsdataset.cpp
    "GDAL_OPEN_AFTER_COPY", // from jpgdataset.cpp, pngdataset.cpp

From 654769f49c3f38bbfa215da21c45f3b438a0087d Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Tue, 24 Dec 2024 15:23:20 +0100
Subject: [PATCH 09/40] 'gdal' CLI: add a warning about experimental status in
 help message

e.g.:
```
$ gdal
ERROR 1: gdal: Missing command name.
Usage: gdal <COMMAND> [OPTIONS]
where <COMMAND> is one of:
  - convert:  Convert a dataset (shortcut for 'gdal raster convert' or 'gdal vector convert').
  - info:     Return information on a dataset (shortcut for 'gdal raster info' or 'gdal vector info').
  - pipeline: Execute a pipeline (shortcut for 'gdal raster pipeline' or 'gdal vector pipeline').
  - raster:   Raster commands.
  - vector:   Vector commands.

Try 'gdal --help' for help.

'gdal <FILENAME>' can also be used as a shortcut for 'gdal info <FILENAME>'.
And 'gdal read <FILENAME> ! ...' as a shortcut for 'gdal pipeline <FILENAME> ! ...'.

For more details, consult https://gdal.org/programs/index.html

WARNING: the gdal command is provisionally provided as an alternative interface to GDAL and OGR command line utilities.
The project reserves the right to modify, rename, reorganize, and change the behavior of the utility
until it is officially frozen in a future feature release of GDAL.
```
---
 gcore/gdalalgorithm.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/gcore/gdalalgorithm.cpp b/gcore/gdalalgorithm.cpp
index e86d90717c44..f8a8d0b70b4b 100644
--- a/gcore/gdalalgorithm.cpp
+++ b/gcore/gdalalgorithm.cpp
@@ -2611,6 +2611,16 @@ GDALAlgorithm::GetUsageForCLI(bool shortUsage,
         osRet += '\n';
     }
 
+    if (!m_callPath.empty() && m_callPath[0] == "gdal")
+    {
+        osRet += "\nWARNING: the gdal command is provisionally provided as an "
+                 "alternative interface to GDAL and OGR command line "
+                 "utilities.\nThe project reserves the right to modify, "
+                 "rename, reorganize, and change the behavior of the utility\n"
+                 "until it is officially frozen in a future feature release of "
+                 "GDAL.\n";
+    }
+
     return osRet;
 }
 

From 41023dbbaa7cc7fb172fc9ae134612fc4599be72 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Mon, 30 Dec 2024 01:32:48 +0100
Subject: [PATCH 10/40] Add VSIGlob() to find files using wildcards '*', '?',
 '['

---
 autotest/cpp/test_cpl.cpp | 144 +++++++++++++++++++++
 doc/source/api/cpl.rst    |   8 ++
 port/cpl_vsi.h            |   2 +
 port/cpl_vsil.cpp         | 265 ++++++++++++++++++++++++++++++++++++++
 4 files changed, 419 insertions(+)

diff --git a/autotest/cpp/test_cpl.cpp b/autotest/cpp/test_cpl.cpp
index 046116e2fbb2..78e9d37c2ee0 100644
--- a/autotest/cpp/test_cpl.cpp
+++ b/autotest/cpp/test_cpl.cpp
@@ -5600,4 +5600,148 @@ TEST_F(test_cpl, VSIMemGenerateHiddenFilename)
         EXPECT_TRUE(ENDS_WITH(pszFilename, "/foo.bar"));
     }
 }
+
+TEST_F(test_cpl, VSIGlob)
+{
+    GByte abyDummyData[1] = {0};
+    const std::string osFilenameRadix = VSIMemGenerateHiddenFilename("");
+    const std::string osFilename = osFilenameRadix + "trick";
+    VSIFCloseL(VSIFileFromMemBuffer(osFilename.c_str(), abyDummyData,
+                                    sizeof(abyDummyData), false));
+
+    {
+        CPLStringList aosRes(
+            VSIGlob(osFilename.c_str(), nullptr, nullptr, nullptr));
+        ASSERT_EQ(aosRes.size(), 1);
+        EXPECT_STREQ(aosRes[0], osFilename.c_str());
+    }
+
+    {
+        CPLStringList aosRes(
+            VSIGlob(osFilename.substr(0, osFilename.size() - 1).c_str(),
+                    nullptr, nullptr, nullptr));
+        ASSERT_EQ(aosRes.size(), 0);
+    }
+
+    {
+        CPLStringList aosRes(
+            VSIGlob(std::string(osFilenameRadix).append("?rick").c_str(),
+                    nullptr, nullptr, nullptr));
+        ASSERT_EQ(aosRes.size(), 1);
+        EXPECT_STREQ(aosRes[0], osFilename.c_str());
+    }
+
+    {
+        CPLStringList aosRes(
+            VSIGlob(std::string(osFilenameRadix).append("?rack").c_str(),
+                    nullptr, nullptr, nullptr));
+        ASSERT_EQ(aosRes.size(), 0);
+    }
+
+    {
+        CPLStringList aosRes(
+            VSIGlob(std::string(osFilenameRadix).append("*ick").c_str(),
+                    nullptr, nullptr, nullptr));
+        ASSERT_EQ(aosRes.size(), 1);
+        EXPECT_STREQ(aosRes[0], osFilename.c_str());
+    }
+
+    {
+        CPLStringList aosRes(
+            VSIGlob(std::string(osFilenameRadix).append("*").c_str(), nullptr,
+                    nullptr, nullptr));
+        ASSERT_EQ(aosRes.size(), 1);
+        EXPECT_STREQ(aosRes[0], osFilename.c_str());
+    }
+
+    {
+        CPLStringList aosRes(
+            VSIGlob(std::string(osFilenameRadix).append("*ack").c_str(),
+                    nullptr, nullptr, nullptr));
+        ASSERT_EQ(aosRes.size(), 0);
+    }
+
+    {
+        CPLStringList aosRes(
+            VSIGlob(std::string(osFilenameRadix).append("*ic*").c_str(),
+                    nullptr, nullptr, nullptr));
+        ASSERT_EQ(aosRes.size(), 1);
+        EXPECT_STREQ(aosRes[0], osFilename.c_str());
+    }
+
+    {
+        CPLStringList aosRes(
+            VSIGlob(std::string(osFilenameRadix).append("*ac*").c_str(),
+                    nullptr, nullptr, nullptr));
+        ASSERT_EQ(aosRes.size(), 0);
+    }
+
+    {
+        CPLStringList aosRes(VSIGlob(
+            std::string(osFilenameRadix).append("[st][!s]ic[j-l]").c_str(),
+            nullptr, nullptr, nullptr));
+        ASSERT_EQ(aosRes.size(), 1);
+        EXPECT_STREQ(aosRes[0], osFilename.c_str());
+    }
+
+    {
+        CPLStringList aosRes(
+            VSIGlob(std::string(osFilenameRadix).append("[!s]rick").c_str(),
+                    nullptr, nullptr, nullptr));
+        ASSERT_EQ(aosRes.size(), 1);
+        EXPECT_STREQ(aosRes[0], osFilename.c_str());
+    }
+
+    {
+        CPLStringList aosRes(
+            VSIGlob(std::string(osFilenameRadix).append("[").c_str(), nullptr,
+                    nullptr, nullptr));
+        ASSERT_EQ(aosRes.size(), 0);
+    }
+
+    const std::string osFilenameWithSpecialChars = osFilenameRadix + "[!-]";
+    VSIFCloseL(VSIFileFromMemBuffer(osFilenameWithSpecialChars.c_str(),
+                                    abyDummyData, sizeof(abyDummyData), false));
+
+    {
+        CPLStringList aosRes(VSIGlob(
+            std::string(osFilenameRadix).append("[[][!]a-][-][]]").c_str(),
+            nullptr, nullptr, nullptr));
+        ASSERT_EQ(aosRes.size(), 1);
+        EXPECT_STREQ(aosRes[0], osFilenameWithSpecialChars.c_str());
+    }
+
+    const std::string osFilename2 = osFilenameRadix + "truck/track";
+    VSIFCloseL(VSIFileFromMemBuffer(osFilename2.c_str(), abyDummyData,
+                                    sizeof(abyDummyData), false));
+
+    {
+        CPLStringList aosRes(
+            VSIGlob(std::string(osFilenameRadix).append("*uc*/track").c_str(),
+                    nullptr, nullptr, nullptr));
+        ASSERT_EQ(aosRes.size(), 1);
+        EXPECT_STREQ(aosRes[0], osFilename2.c_str());
+    }
+
+    {
+        CPLStringList aosRes(
+            VSIGlob(std::string(osFilenameRadix).append("*uc*/truck").c_str(),
+                    nullptr, nullptr, nullptr));
+        ASSERT_EQ(aosRes.size(), 0);
+    }
+
+    {
+        CPLStringList aosRes(
+            VSIGlob(std::string(osFilenameRadix).append("**/track").c_str(),
+                    nullptr, nullptr, nullptr));
+        ASSERT_EQ(aosRes.size(), 1);
+        EXPECT_STREQ(aosRes[0], osFilename2.c_str());
+    }
+
+    VSIUnlink(osFilename.c_str());
+    VSIUnlink(osFilenameWithSpecialChars.c_str());
+    VSIUnlink(osFilename2.c_str());
+    VSIUnlink(osFilenameRadix.c_str());
+}
+
 }  // namespace
diff --git a/doc/source/api/cpl.rst b/doc/source/api/cpl.rst
index 0724303fcfa8..3feeee965481 100644
--- a/doc/source/api/cpl.rst
+++ b/doc/source/api/cpl.rst
@@ -96,3 +96,11 @@ cpl_vsi.h
 .. seealso::
 
    :ref:`cpl_cpp_api`.
+
+
+.. below is an allow-list for spelling checker.
+
+.. spelling:word-list::
+    subdir
+    subsubdir
+
diff --git a/port/cpl_vsi.h b/port/cpl_vsi.h
index c9f5d801f1e9..1bdd7005470a 100644
--- a/port/cpl_vsi.h
+++ b/port/cpl_vsi.h
@@ -380,6 +380,8 @@ char CPL_DLL **VSIReadDir(const char *);
 char CPL_DLL **VSIReadDirRecursive(const char *pszPath);
 char CPL_DLL **VSIReadDirEx(const char *pszPath, int nMaxFiles);
 char CPL_DLL **VSISiblingFiles(const char *pszPath);
+char CPL_DLL **VSIGlob(const char *pszPattern, const char *const *papszOptions,
+                       GDALProgressFunc pProgressFunc, void *pProgressData);
 
 const char CPL_DLL *VSIGetDirectorySeparator(const char *pszPath);
 
diff --git a/port/cpl_vsil.cpp b/port/cpl_vsil.cpp
index df8cd588cde7..9593bfe09370 100644
--- a/port/cpl_vsil.cpp
+++ b/port/cpl_vsil.cpp
@@ -139,6 +139,271 @@ char **VSISiblingFiles(const char *pszFilename)
     return poFSHandler->SiblingFiles(pszFilename);
 }
 
+/************************************************************************/
+/*                           VSIFnMatch()                               */
+/************************************************************************/
+
+static bool VSIFnMatch(const char *pszPattern, const char *pszStr)
+{
+    for (; *pszPattern && *pszStr; pszPattern++, pszStr++)
+    {
+        if (*pszPattern == '*')
+        {
+            if (pszPattern[1] == 0)
+                return true;
+            for (; *pszStr; ++pszStr)
+            {
+                if (VSIFnMatch(pszPattern + 1, pszStr))
+                    return true;
+            }
+            return false;
+        }
+        else if (*pszPattern == '?')
+        {
+            // match single any char
+        }
+        else if (*pszPattern == '[')
+        {
+            // match character classes and ranges
+            // "[abcd]" will match a character that is a, b, c or d
+            // "[a-z]" will match a character that is a to z
+            // "[!abcd] will match a character that is *not* a, b, c or d
+            // "[]]" will match character ]
+            // "[]-]" will match character ] or -
+            // "[!]a-]" will match a character that is *not* ], a or -
+
+            const char *pszOpenBracket = pszPattern;
+            ++pszPattern;
+            const bool isNot = (*pszPattern == '!');
+            if (isNot)
+            {
+                ++pszOpenBracket;
+                ++pszPattern;
+            }
+            bool res = false;
+            for (; *pszPattern; ++pszPattern)
+            {
+                if ((*pszPattern == ']' || *pszPattern == '-') &&
+                    pszPattern == pszOpenBracket + 1)
+                {
+                    if (*pszStr == *pszPattern)
+                    {
+                        res = true;
+                    }
+                }
+                else if (*pszPattern == ']')
+                {
+                    break;
+                }
+                else if (pszPattern[1] == '-' && pszPattern[2] != 0 &&
+                         pszPattern[2] != ']')
+                {
+                    if (*pszStr >= pszPattern[0] && *pszStr <= pszPattern[2])
+                    {
+                        res = true;
+                    }
+                    pszPattern += 2;
+                }
+                else if (*pszStr == *pszPattern)
+                {
+                    res = true;
+                }
+            }
+            if (*pszPattern == 0)
+                return false;
+            if (!res && !isNot)
+                return false;
+            if (res && isNot)
+                return false;
+        }
+        else if (*pszPattern != *pszStr)
+        {
+            return false;
+        }
+    }
+    return *pszPattern == 0 && *pszStr == 0;
+}
+
+/************************************************************************/
+/*                             VSIGlob()                                */
+/************************************************************************/
+
+/**
+ \brief Return a list of file and directory names matching
+ a pattern that can contain wildcards.
+
+ This function has similar behavior to the POSIX glob() function:
+ https://man7.org/linux/man-pages/man7/glob.7.html
+
+ In particular it supports the following wildcards:
+ <ul>
+ <li>'*': match any string</li>
+ <li>'?': match any single character</li>
+ <li>'[': match character class or range, with '!' immediately after '['
+ to indicate negation.</li>
+ </ul>
+ Refer to to the above man page for more details.
+
+ It also supports the "**" recursive wildcard, behaving similarly to Python
+ glob.glob() with recursive=True. Be careful of the amount of memory and time
+ required when using that recursive wildcard on directories with a large
+ amount of files and subdirectories.
+
+ Examples, given a file hierarchy:
+ - one.tif
+ - my_subdir/two.tif
+ - my_subdir/subsubdir/three.tif
+
+ \code{.cpp}
+ VSIGlob("one.tif",NULL,NULL,NULL) returns ["one.tif", NULL]
+ VSIGlob("*.tif",NULL,NULL,NULL) returns ["one.tif", NULL]
+ VSIGlob("on?.tif",NULL,NULL,NULL) returns ["one.tif", NULL]
+ VSIGlob("on[a-z].tif",NULL,NULL,NULL) returns ["one.tif", NULL]
+ VSIGlob("on[ef].tif",NULL,NULL,NULL) returns ["one.tif", NULL]
+ VSIGlob("on[!e].tif",NULL,NULL,NULL) returns NULL
+ VSIGlob("my_subdir" "/" "*.tif",NULL,NULL,NULL) returns ["my_subdir/two.tif", NULL]
+ VSIGlob("**" "/" "*.tif",NULL,NULL,NULL) returns ["one.tif", "my_subdir/two.tif", "my_subdir/subsubdir/three.tif", NULL]
+ \endcode
+
+ In the current implementation, matching is done based on the assumption that
+ a character fits into a single byte, which will not work properly on
+ non-ASCII UTF-8 filenames.
+
+ VSIGlob() works with any virtual file systems supported by GDAL, including
+ network file systems such as /vsis3/, /vsigs/, /vsiaz/, etc. But note that
+ for those ones, the pattern is not passed to the remote server, and thus large
+ amount of filenames can be transferred from the remote server to the host
+ where the filtering is done.
+
+ @param pszPattern the relative, or absolute path of a directory to read.
+ UTF-8 encoded.
+ @param papszOptions NULL-terminate list of options, or NULL. None supported
+ currently.
+ @param pProgressFunc Progress function, or NULL. This is only used as a way
+ for the user to cancel operation if it takes too much time. The percentage
+ passed to the callback is not significant (always at 0).
+ @param pProgressData User data passed to the progress function, or NULL.
+ @return The list of matched filenames, which must be freed with CSLDestroy().
+ Filenames are returned in UTF-8 encoding.
+
+ @since GDAL 3.11
+*/
+
+char **VSIGlob(const char *pszPattern, const char *const *papszOptions,
+               GDALProgressFunc pProgressFunc, void *pProgressData)
+{
+    CPL_IGNORE_RET_VAL(papszOptions);
+
+    CPLStringList aosRes;
+    std::vector<std::pair<std::string, size_t>> candidates;
+    candidates.emplace_back(pszPattern, 0);
+    while (!candidates.empty())
+    {
+        auto [osPattern, nPosStart] = candidates.back();
+        pszPattern = osPattern.c_str() + nPosStart;
+        candidates.pop_back();
+
+        std::string osPath = osPattern.substr(0, nPosStart);
+        std::string osCurPath;
+        for (;; ++pszPattern)
+        {
+            if (*pszPattern == 0 || *pszPattern == '/' || *pszPattern == '\\')
+            {
+                struct VSIDirCloser
+                {
+                    void operator()(VSIDIR *dir)
+                    {
+                        VSICloseDir(dir);
+                    }
+                };
+
+                if (osCurPath == "**")
+                {
+                    std::unique_ptr<VSIDIR, VSIDirCloser> psDir(
+                        VSIOpenDir(osPath.c_str(), -1, nullptr));
+                    if (!psDir)
+                        return nullptr;
+                    while (const VSIDIREntry *psEntry =
+                               VSIGetNextDirEntry(psDir.get()))
+                    {
+                        if (pProgressFunc &&
+                            !pProgressFunc(0, "", pProgressData))
+                        {
+                            return nullptr;
+                        }
+                        {
+                            std::string osCandidate(osPath);
+                            osCandidate += psEntry->pszName;
+                            nPosStart = osCandidate.size();
+                            if (*pszPattern)
+                            {
+                                osCandidate += pszPattern;
+                            }
+                            candidates.emplace_back(std::move(osCandidate),
+                                                    nPosStart);
+                        }
+                    }
+                    osPath.clear();
+                    break;
+                }
+                else if (osCurPath.find_first_of("*?[") != std::string::npos)
+                {
+                    std::unique_ptr<VSIDIR, VSIDirCloser> psDir(
+                        VSIOpenDir(osPath.c_str(), 0, nullptr));
+                    if (!psDir)
+                        return nullptr;
+                    while (const VSIDIREntry *psEntry =
+                               VSIGetNextDirEntry(psDir.get()))
+                    {
+                        if (pProgressFunc &&
+                            !pProgressFunc(0, "", pProgressData))
+                        {
+                            return nullptr;
+                        }
+                        if (VSIFnMatch(osCurPath.c_str(), psEntry->pszName))
+                        {
+                            std::string osCandidate(osPath);
+                            osCandidate += psEntry->pszName;
+                            nPosStart = osCandidate.size();
+                            if (*pszPattern)
+                            {
+                                osCandidate += pszPattern;
+                            }
+                            candidates.emplace_back(std::move(osCandidate),
+                                                    nPosStart);
+                        }
+                    }
+                    osPath.clear();
+                    break;
+                }
+                else if (*pszPattern == 0)
+                {
+                    osPath += osCurPath;
+                    break;
+                }
+                else
+                {
+                    osPath += osCurPath;
+                    osPath += *pszPattern;
+                    osCurPath.clear();
+                }
+            }
+            else
+            {
+                osCurPath += *pszPattern;
+            }
+        }
+        if (!osPath.empty())
+        {
+            VSIStatBufL sStat;
+            if (VSIStatL(osPath.c_str(), &sStat) == 0)
+                aosRes.AddString(osPath.c_str());
+        }
+    }
+
+    return aosRes.StealList();
+}
+
 /************************************************************************/
 /*                      VSIGetDirectorySeparator()                      */
 /************************************************************************/

From 54000cfecadfe14a0edcbe24fddb21366dedd143 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Mon, 30 Dec 2024 02:12:46 +0100
Subject: [PATCH 11/40] Add CPLString::push_back()

---
 port/cpl_string.h | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/port/cpl_string.h b/port/cpl_string.h
index 8da2aee05f30..ab0aaeb2d43d 100644
--- a/port/cpl_string.h
+++ b/port/cpl_string.h
@@ -489,6 +489,18 @@ extern "C++"
         CPLStringList &AddString(const char *pszNewString);
         CPLStringList &AddStringDirectly(char *pszNewString);
 
+        /** Add a string to the list */
+        void push_back(const char *pszNewString)
+        {
+            AddString(pszNewString);
+        }
+
+        /** Add a string to the list */
+        void push_back(const std::string &osStr)
+        {
+            AddString(osStr.c_str());
+        }
+
         CPLStringList &InsertString(int nInsertAtLineNo, const char *pszNewLine)
         {
             return InsertStringDirectly(nInsertAtLineNo, CPLStrdup(pszNewLine));

From 7572ceea9e09603089b2cc72588880a7d3571498 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Mon, 30 Dec 2024 03:41:06 +0100
Subject: [PATCH 12/40] Add 'gdal raster buildvrt'

---
 apps/CMakeLists.txt                           |   1 +
 apps/gdalalg_raster.cpp                       |   2 +
 apps/gdalalg_raster_buildvrt.cpp              | 277 +++++++++++++
 apps/gdalalg_raster_buildvrt.h                |  59 +++
 .../utilities/test_gdalalg_raster_buildvrt.py | 363 ++++++++++++++++++
 .../utilities/test_gdalalg_raster_edit.py     |   2 +-
 doc/source/conf.py                            |   7 +
 doc/source/programs/gdal_raster.rst           |   2 +
 doc/source/programs/gdal_raster_buildvrt.rst  | 181 +++++++++
 doc/source/programs/index.rst                 |   2 +
 gcore/gdalalgorithm.cpp                       |  55 ++-
 gcore/gdalalgorithm.h                         |  66 +++-
 swig/include/Algorithm.i                      |  17 +-
 swig/include/python/gdal_python.i             |  12 +-
 14 files changed, 1018 insertions(+), 28 deletions(-)
 create mode 100644 apps/gdalalg_raster_buildvrt.cpp
 create mode 100644 apps/gdalalg_raster_buildvrt.h
 create mode 100755 autotest/utilities/test_gdalalg_raster_buildvrt.py
 create mode 100644 doc/source/programs/gdal_raster_buildvrt.rst

diff --git a/apps/CMakeLists.txt b/apps/CMakeLists.txt
index 6fb96bc274e2..e37a04fc79f1 100644
--- a/apps/CMakeLists.txt
+++ b/apps/CMakeLists.txt
@@ -11,6 +11,7 @@ add_library(
   gdalalg_main.cpp
   gdalalg_pipeline.cpp
   gdalalg_raster.cpp
+  gdalalg_raster_buildvrt.cpp
   gdalalg_raster_info.cpp
   gdalalg_raster_convert.cpp
   gdalalg_raster_edit.cpp
diff --git a/apps/gdalalg_raster.cpp b/apps/gdalalg_raster.cpp
index 22fed2833aa6..b2975197a303 100644
--- a/apps/gdalalg_raster.cpp
+++ b/apps/gdalalg_raster.cpp
@@ -12,6 +12,7 @@
 
 #include "gdalalgorithm.h"
 
+#include "gdalalg_raster_buildvrt.h"
 #include "gdalalg_raster_info.h"
 #include "gdalalg_raster_convert.h"
 #include "gdalalg_raster_edit.h"
@@ -41,6 +42,7 @@ class GDALRasterAlgorithm final : public GDALAlgorithm
         RegisterSubAlgorithm<GDALRasterEditAlgorithmStandalone>();
         RegisterSubAlgorithm<GDALRasterPipelineAlgorithm>();
         RegisterSubAlgorithm<GDALRasterReprojectAlgorithmStandalone>();
+        RegisterSubAlgorithm<GDALRasterBuildVRTAlgorithm>();
     }
 
   private:
diff --git a/apps/gdalalg_raster_buildvrt.cpp b/apps/gdalalg_raster_buildvrt.cpp
new file mode 100644
index 000000000000..e8d32df67e5d
--- /dev/null
+++ b/apps/gdalalg_raster_buildvrt.cpp
@@ -0,0 +1,277 @@
+/******************************************************************************
+ *
+ * Project:  GDAL
+ * Purpose:  gdal "raster buildvrt" subcommand
+ * Author:   Even Rouault <even dot rouault at spatialys.com>
+ *
+ ******************************************************************************
+ * Copyright (c) 2024, Even Rouault <even dot rouault at spatialys.com>
+ *
+ * SPDX-License-Identifier: MIT
+ ****************************************************************************/
+
+#include "gdalalg_raster_buildvrt.h"
+
+#include "cpl_conv.h"
+#include "cpl_vsi_virtual.h"
+
+#include "gdal_priv.h"
+#include "gdal_utils.h"
+
+//! @cond Doxygen_Suppress
+
+#ifndef _
+#define _(x) (x)
+#endif
+
+/************************************************************************/
+/*        GDALRasterBuildVRTAlgorithm::GDALRasterBuildVRTAlgorithm()    */
+/************************************************************************/
+
+GDALRasterBuildVRTAlgorithm::GDALRasterBuildVRTAlgorithm()
+    : GDALAlgorithm(NAME, DESCRIPTION, HELP_URL)
+{
+    AddProgressArg();
+    AddArg(GDAL_ARG_NAME_INPUT, 'i',
+           _("Input raster datasets (or specify a @<filename> to point to a "
+             "file containing filenames)"),
+           &m_inputDatasets, GDAL_OF_RASTER)
+        .SetPositional()
+        .SetMinCount(1)
+        .SetAutoOpenDataset(false)
+        .SetMetaVar("INPUTS");
+    AddOutputDatasetArg(&m_outputDataset, GDAL_OF_RASTER);
+    AddCreationOptionsArg(&m_creationOptions);
+    AddArg("band", 'b', _("Specify input band(s) number."), &m_bands);
+    AddArg("separate", 0, _("Place each input file into a separate band."),
+           &m_separate);
+    AddOverwriteArg(&m_overwrite);
+    {
+        auto &arg = AddArg("resolution", 0,
+                           _("Target resolution (in destination CRS units)"),
+                           &m_resolution)
+                        .SetMetaVar("<xres>,<yres>|average|highest|lowest");
+        arg.AddValidationAction(
+            [this, &arg]()
+            {
+                const std::string val = arg.Get<std::string>();
+                if (val != "average" && val != "highest" && val != "lowest")
+                {
+                    const auto aosTokens =
+                        CPLStringList(CSLTokenizeString2(val.c_str(), ",", 0));
+                    if (aosTokens.size() != 2 ||
+                        CPLGetValueType(aosTokens[0]) == CPL_VALUE_STRING ||
+                        CPLGetValueType(aosTokens[1]) == CPL_VALUE_STRING ||
+                        CPLAtof(aosTokens[0]) <= 0 ||
+                        CPLAtof(aosTokens[1]) <= 0)
+                    {
+                        ReportError(CE_Failure, CPLE_AppDefined,
+                                    "resolution: two comma separated positive "
+                                    "values should be provided, or 'average', "
+                                    "'highest' or 'lowest'");
+                        return false;
+                    }
+                }
+                return true;
+            });
+    }
+    AddBBOXArg(&m_bbox, _("Target bounding box as xmin,ymin,xmax,ymax (in "
+                          "destination CRS units)"));
+    AddArg("target-aligned-pixels", 0,
+           _("Round target extent to target resolution"),
+           &m_targetAlignedPixels)
+        .AddHiddenAlias("tap");
+    AddArg("srcnodata", 0, _("Set nodata values for input bands."),
+           &m_srcNoData)
+        .SetMinCount(1)
+        .SetRepeatedArgAllowed(false);
+    AddArg("vrtnodata", 0, _("Set nodata values at the VRT band level."),
+           &m_vrtNoData)
+        .SetMinCount(1)
+        .SetRepeatedArgAllowed(false);
+    AddArg("hidenodata", 0, _("Makes the VRT band not report the NoData."),
+           &m_hideNoData);
+    AddArg("addalpha", 0,
+           _("Adds an alpha mask band to the VRT when the source raster have "
+             "none."),
+           &m_addAlpha);
+}
+
+/************************************************************************/
+/*                  GDALRasterBuildVRTAlgorithm::RunImpl()              */
+/************************************************************************/
+
+bool GDALRasterBuildVRTAlgorithm::RunImpl(GDALProgressFunc pfnProgress,
+                                          void *pProgressData)
+{
+    if (m_outputDataset.GetDatasetRef())
+    {
+        ReportError(CE_Failure, CPLE_NotSupported,
+                    "gdal raster buildvrt does not support outputting to an "
+                    "already opened output dataset");
+        return false;
+    }
+
+    std::vector<GDALDatasetH> ahInputDatasets;
+    CPLStringList aosInputDatasetNames;
+    bool foundByRef = false;
+    bool foundByName = false;
+    for (auto &ds : m_inputDatasets)
+    {
+        if (ds.GetDatasetRef())
+        {
+            foundByRef = true;
+            ahInputDatasets.push_back(
+                GDALDataset::ToHandle(ds.GetDatasetRef()));
+        }
+        else if (!ds.GetName().empty())
+        {
+            foundByName = true;
+            if (ds.GetName()[0] == '@')
+            {
+                auto f = VSIVirtualHandleUniquePtr(
+                    VSIFOpenL(ds.GetName().c_str() + 1, "r"));
+                if (!f)
+                {
+                    ReportError(CE_Failure, CPLE_FileIO, "Cannot open %s",
+                                ds.GetName().c_str() + 1);
+                    return false;
+                }
+                while (const char *filename = CPLReadLineL(f.get()))
+                {
+                    aosInputDatasetNames.push_back(filename);
+                }
+            }
+            else if (ds.GetName().find_first_of("*?[") != std::string::npos)
+            {
+                CPLStringList aosMatches(VSIGlob(ds.GetName().c_str(), nullptr,
+                                                 pfnProgress, pProgressData));
+                for (const char *pszStr : aosMatches)
+                {
+                    aosInputDatasetNames.push_back(pszStr);
+                }
+            }
+            else
+            {
+                aosInputDatasetNames.push_back(ds.GetName().c_str());
+            }
+        }
+    }
+    if (foundByName && foundByRef)
+    {
+        ReportError(CE_Failure, CPLE_NotSupported,
+                    "Input datasets should be provided either all by reference "
+                    "or all by name");
+        return false;
+    }
+
+    VSIStatBufL sStat;
+    if (!m_overwrite && !m_outputDataset.GetName().empty() &&
+        (VSIStatL(m_outputDataset.GetName().c_str(), &sStat) == 0 ||
+         std::unique_ptr<GDALDataset>(
+             GDALDataset::Open(m_outputDataset.GetName().c_str()))))
+    {
+        ReportError(CE_Failure, CPLE_AppDefined,
+                    "File '%s' already exists. Specify the --overwrite "
+                    "option to overwrite it.",
+                    m_outputDataset.GetName().c_str());
+        return false;
+    }
+
+    CPLStringList aosOptions;
+    if (!m_resolution.empty())
+    {
+        const auto aosTokens =
+            CPLStringList(CSLTokenizeString2(m_resolution.c_str(), ",", 0));
+        if (aosTokens.size() == 2)
+        {
+            aosOptions.push_back("-tr");
+            aosOptions.push_back(aosTokens[0]);
+            aosOptions.push_back(aosTokens[1]);
+        }
+        else
+        {
+            aosOptions.push_back("-resolution");
+            aosOptions.push_back(m_resolution);
+        }
+    }
+    if (!m_bbox.empty())
+    {
+        aosOptions.push_back("-te");
+        aosOptions.push_back(CPLSPrintf("%.17g", m_bbox[0]));
+        aosOptions.push_back(CPLSPrintf("%.17g", m_bbox[1]));
+        aosOptions.push_back(CPLSPrintf("%.17g", m_bbox[2]));
+        aosOptions.push_back(CPLSPrintf("%.17g", m_bbox[3]));
+    }
+    if (m_targetAlignedPixels)
+    {
+        aosOptions.push_back("-tap");
+    }
+    if (!m_srcNoData.empty())
+    {
+        aosOptions.push_back("-srcnodata");
+        std::string s;
+        for (double v : m_srcNoData)
+        {
+            if (!s.empty())
+                s += " ";
+            s += CPLSPrintf("%.17g", v);
+        }
+        aosOptions.push_back(s);
+    }
+    if (!m_vrtNoData.empty())
+    {
+        aosOptions.push_back("-vrtnodata");
+        std::string s;
+        for (double v : m_vrtNoData)
+        {
+            if (!s.empty())
+                s += " ";
+            s += CPLSPrintf("%.17g", v);
+        }
+        aosOptions.push_back(s);
+    }
+    if (m_separate)
+    {
+        aosOptions.push_back("-separate");
+    }
+    for (const auto &co : m_creationOptions)
+    {
+        aosOptions.push_back("-co");
+        aosOptions.push_back(co);
+    }
+    for (const int b : m_bands)
+    {
+        aosOptions.push_back("-b");
+        aosOptions.push_back(CPLSPrintf("%d", b));
+    }
+    if (m_addAlpha)
+    {
+        aosOptions.push_back("-addalpha");
+    }
+    if (m_hideNoData)
+    {
+        aosOptions.push_back("-hidenodata");
+    }
+
+    GDALBuildVRTOptions *psOptions =
+        GDALBuildVRTOptionsNew(aosOptions.List(), nullptr);
+    GDALBuildVRTOptionsSetProgress(psOptions, pfnProgress, pProgressData);
+
+    auto poOutDS = std::unique_ptr<GDALDataset>(GDALDataset::FromHandle(
+        GDALBuildVRT(m_outputDataset.GetName().c_str(),
+                     foundByName ? aosInputDatasetNames.size()
+                                 : static_cast<int>(m_inputDatasets.size()),
+                     ahInputDatasets.empty() ? nullptr : ahInputDatasets.data(),
+                     aosInputDatasetNames.List(), psOptions, nullptr)));
+    GDALBuildVRTOptionsFree(psOptions);
+    const bool bOK = poOutDS != nullptr;
+    if (bOK)
+    {
+        m_outputDataset.Set(std::move(poOutDS));
+    }
+
+    return bOK;
+}
+
+//! @endcond
diff --git a/apps/gdalalg_raster_buildvrt.h b/apps/gdalalg_raster_buildvrt.h
new file mode 100644
index 000000000000..d01a562431eb
--- /dev/null
+++ b/apps/gdalalg_raster_buildvrt.h
@@ -0,0 +1,59 @@
+/******************************************************************************
+ *
+ * Project:  GDAL
+ * Purpose:  gdal "raster buildvrt" subcommand
+ * Author:   Even Rouault <even dot rouault at spatialys.com>
+ *
+ ******************************************************************************
+ * Copyright (c) 2024, Even Rouault <even dot rouault at spatialys.com>
+ *
+ * SPDX-License-Identifier: MIT
+ ****************************************************************************/
+
+#ifndef GDALALG_RASTER_BUILDVRT_INCLUDED
+#define GDALALG_RASTER_BUILDVRT_INCLUDED
+
+#include "gdalalgorithm.h"
+
+//! @cond Doxygen_Suppress
+
+/************************************************************************/
+/*                     GDALRasterBuildVRTAlgorithm                       */
+/************************************************************************/
+
+class GDALRasterBuildVRTAlgorithm final : public GDALAlgorithm
+{
+  public:
+    static constexpr const char *NAME = "buildvrt";
+    static constexpr const char *DESCRIPTION = "Build a virtual dataset (VRT).";
+    static constexpr const char *HELP_URL =
+        "/programs/gdal_raster_buildvrt.html";
+
+    static std::vector<std::string> GetAliases()
+    {
+        return {};
+    }
+
+    explicit GDALRasterBuildVRTAlgorithm();
+
+  private:
+    bool RunImpl(GDALProgressFunc pfnProgress, void *pProgressData) override;
+
+    std::vector<GDALArgDatasetValue> m_inputDatasets{};
+    GDALArgDatasetValue m_outputDataset{};
+    std::vector<std::string> m_creationOptions{};
+    bool m_overwrite = false;
+    bool m_separate = false;
+    std::string m_resolution{};
+    std::vector<double> m_bbox{};
+    bool m_targetAlignedPixels = false;
+    std::vector<double> m_srcNoData{};
+    std::vector<double> m_vrtNoData{};
+    std::vector<int> m_bands{};
+    bool m_hideNoData = false;
+    bool m_addAlpha = false;
+};
+
+//! @endcond
+
+#endif
diff --git a/autotest/utilities/test_gdalalg_raster_buildvrt.py b/autotest/utilities/test_gdalalg_raster_buildvrt.py
new file mode 100755
index 000000000000..5a944567ffa7
--- /dev/null
+++ b/autotest/utilities/test_gdalalg_raster_buildvrt.py
@@ -0,0 +1,363 @@
+#!/usr/bin/env pytest
+# -*- coding: utf-8 -*-
+###############################################################################
+# Project:  GDAL/OGR Test Suite
+# Purpose:  'gdal raster buildvrt' testing
+# Author:   Even Rouault <even dot rouault @ spatialys.com>
+#
+###############################################################################
+# Copyright (c) 2024, Even Rouault <even dot rouault at spatialys.com>
+#
+# SPDX-License-Identifier: MIT
+###############################################################################
+
+import pytest
+
+from osgeo import gdal
+
+
+def get_buildvrt_alg():
+    reg = gdal.GetGlobalAlgorithmRegistry()
+    raster = reg.InstantiateAlg("raster")
+    return raster.InstantiateSubAlgorithm("buildvrt")
+
+
+def test_gdalalg_raster_buildvrt_from_dataset_handle():
+
+    alg = get_buildvrt_alg()
+    alg.GetArg("input").Set(
+        [
+            gdal.Translate(
+                "", "../gcore/data/byte.tif", options="-f MEM -srcwin 0 0 10 20"
+            ),
+            gdal.Translate(
+                "", "../gcore/data/byte.tif", options="-f MEM -srcwin 10 0 10 20"
+            ),
+        ]
+    )
+    alg.GetArg("output").Set("")
+    assert alg.Run()
+    ds = alg.GetArg("output").Get().GetDataset()
+    assert ds.RasterXSize == 20
+    assert ds.RasterYSize == 20
+    assert ds.GetGeoTransform() == pytest.approx(
+        (440720.0, 60.0, 0.0, 3751320.0, 0.0, -60.0)
+    )
+    assert ds.GetRasterBand(1).Checksum() == 4672
+
+
+def test_gdalalg_raster_buildvrt_from_dataset_name():
+
+    alg = get_buildvrt_alg()
+    alg.GetArg("input").Set(["../gcore/data/byte.tif"])
+    alg.GetArg("output").Set("")
+    assert alg.Run()
+    ds = alg.GetArg("output").Get().GetDataset()
+    assert ds.RasterXSize == 20
+    assert ds.RasterYSize == 20
+    assert ds.GetGeoTransform() == pytest.approx(
+        (440720.0, 60.0, 0.0, 3751320.0, 0.0, -60.0)
+    )
+    assert ds.GetRasterBand(1).Checksum() == 4672
+
+
+def test_gdalalg_raster_buildvrt_overwrite(tmp_vsimem):
+
+    out_filename = str(tmp_vsimem / "out.tif")
+
+    alg = get_buildvrt_alg()
+    assert alg.ParseRunAndFinalize(["../gcore/data/utmsmall.tif", out_filename])
+
+    with gdal.Open(out_filename) as ds:
+        assert ds.GetRasterBand(1).Checksum() == 50054
+
+    alg = get_buildvrt_alg()
+    with pytest.raises(
+        Exception, match="already exists. Specify the --overwrite option"
+    ):
+        alg.ParseRunAndFinalize(["../gcore/data/byte.tif", out_filename])
+
+    alg = get_buildvrt_alg()
+    assert alg.ParseRunAndFinalize(
+        ["--overwrite", "../gcore/data/byte.tif", out_filename]
+    )
+
+    with gdal.Open(out_filename) as ds:
+        assert ds.GetRasterBand(1).Checksum() == 4672
+
+
+def test_gdalalg_raster_buildvrt_separate(tmp_vsimem):
+
+    tmp_filename = str(tmp_vsimem / "tmp.tif")
+    gdal.Translate(tmp_filename, "../gcore/data/byte.tif", options="-scale 0 255 255 0")
+
+    alg = get_buildvrt_alg()
+    assert alg.ParseCommandLineArguments(
+        [
+            "--separate",
+            "../gcore/data/byte.tif",
+            tmp_filename,
+            "",
+        ]
+    )
+    assert alg.Run()
+    ds = alg.GetArg("output").Get().GetDataset()
+    assert ds.RasterCount == 2
+    assert ds.RasterXSize == 20
+    assert ds.RasterYSize == 20
+    assert ds.GetGeoTransform() == pytest.approx(
+        (440720.0, 60.0, 0.0, 3751320.0, 0.0, -60.0)
+    )
+    assert ds.GetRasterBand(1).Checksum() == 4672
+    assert ds.GetRasterBand(2).Checksum() == 4563
+
+
+def test_gdalalg_raster_buildvrt_bbox():
+
+    alg = get_buildvrt_alg()
+    assert alg.ParseCommandLineArguments(
+        [
+            "--bbox=440780.0,3750180.0,441860.0,3751260.0",
+            "../gcore/data/byte.tif",
+            "",
+        ]
+    )
+    assert alg.Run()
+    ds = alg.GetArg("output").Get().GetDataset()
+    assert ds.RasterXSize == 18
+    assert ds.RasterYSize == 18
+    assert ds.GetGeoTransform() == pytest.approx(
+        (440780.0, 60.0, 0.0, 3751260.0, 0.0, -60.0)
+    )
+    assert ds.GetRasterBand(1).Checksum() == 3695
+
+
+def test_gdalalg_raster_buildvrt_resolution_average():
+
+    src1_ds = gdal.GetDriverByName("MEM").Create("", 1, 1)
+    src1_ds.SetGeoTransform([2, 1, 0, 49, 0, -1])
+    src2_ds = gdal.GetDriverByName("MEM").Create("", 2, 2)
+    src2_ds.SetGeoTransform([3, 0.5, 0, 49, 0, -0.5])
+
+    alg = get_buildvrt_alg()
+    alg.GetArg("input").Set([src1_ds, src2_ds])
+    alg.GetArg("output").Set("")
+    assert alg.Run()
+    ds = alg.GetArg("output").Get().GetDataset()
+    assert ds.RasterXSize == 3
+    assert ds.RasterYSize == 1
+    assert ds.GetGeoTransform() == pytest.approx((2.0, 0.75, 0.0, 49.0, 0.0, -0.75))
+
+
+def test_gdalalg_raster_buildvrt_resolution_highest():
+
+    src1_ds = gdal.GetDriverByName("MEM").Create("", 1, 1)
+    src1_ds.SetGeoTransform([2, 1, 0, 49, 0, -1])
+    src2_ds = gdal.GetDriverByName("MEM").Create("", 2, 2)
+    src2_ds.SetGeoTransform([3, 0.5, 0, 49, 0, -0.5])
+
+    alg = get_buildvrt_alg()
+    alg.GetArg("input").Set([src1_ds, src2_ds])
+    alg.GetArg("output").Set("")
+    alg.GetArg("resolution").Set("highest")
+    assert alg.Run()
+    ds = alg.GetArg("output").Get().GetDataset()
+    assert ds.RasterXSize == 4
+    assert ds.RasterYSize == 2
+    assert ds.GetGeoTransform() == pytest.approx((2.0, 0.5, 0.0, 49.0, 0.0, -0.5))
+
+
+def test_gdalalg_raster_buildvrt_resolution_lowest():
+
+    src1_ds = gdal.GetDriverByName("MEM").Create("", 1, 1)
+    src1_ds.SetGeoTransform([2, 1, 0, 49, 0, -1])
+    src2_ds = gdal.GetDriverByName("MEM").Create("", 2, 2)
+    src2_ds.SetGeoTransform([3, 0.5, 0, 49, 0, -0.5])
+
+    alg = get_buildvrt_alg()
+    alg.GetArg("input").Set([src1_ds, src2_ds])
+    alg.GetArg("output").Set("")
+    alg.GetArg("resolution").Set("lowest")
+    assert alg.Run()
+    ds = alg.GetArg("output").Get().GetDataset()
+    assert ds.RasterXSize == 2
+    assert ds.RasterYSize == 1
+    assert ds.GetGeoTransform() == pytest.approx((2.0, 1.0, 0.0, 49.0, 0.0, -1.0))
+
+
+def test_gdalalg_raster_buildvrt_resolution_custom():
+
+    src1_ds = gdal.GetDriverByName("MEM").Create("", 1, 1)
+    src1_ds.SetGeoTransform([2, 1, 0, 49, 0, -1])
+    src2_ds = gdal.GetDriverByName("MEM").Create("", 2, 2)
+    src2_ds.SetGeoTransform([3, 0.5, 0, 49, 0, -0.5])
+
+    alg = get_buildvrt_alg()
+    alg.GetArg("input").Set([src1_ds, src2_ds])
+    alg.GetArg("output").Set("")
+    alg.GetArg("resolution").Set("0.5,1")
+    assert alg.Run()
+    ds = alg.GetArg("output").Get().GetDataset()
+    assert ds.RasterXSize == 4
+    assert ds.RasterYSize == 1
+    assert ds.GetGeoTransform() == pytest.approx((2.0, 0.5, 0.0, 49.0, 0.0, -1.0))
+
+
+def test_gdalalg_raster_buildvrt_target_aligned_pixels():
+
+    src1_ds = gdal.GetDriverByName("MEM").Create("", 1, 1)
+    src1_ds.SetGeoTransform([2, 1, 0, 49, 0, -1])
+    src2_ds = gdal.GetDriverByName("MEM").Create("", 2, 2)
+    src2_ds.SetGeoTransform([3, 0.5, 0, 49, 0, -0.5])
+
+    alg = get_buildvrt_alg()
+    alg.GetArg("input").Set([src1_ds, src2_ds])
+    alg.GetArg("output").Set("")
+    alg.GetArg("resolution").Set("0.3,0.6")
+    alg.GetArg("target-aligned-pixels").Set(True)
+    assert alg.Run()
+    ds = alg.GetArg("output").Get().GetDataset()
+    assert ds.RasterXSize == 8
+    assert ds.RasterYSize == 2
+    assert ds.GetGeoTransform() == pytest.approx((1.8, 0.3, 0.0, 49.2, 0.0, -0.6))
+
+
+def test_gdalalg_raster_buildvrt_resolution_invalid():
+
+    alg = get_buildvrt_alg()
+    with pytest.raises(
+        Exception,
+        match="resolution: two comma separated positive values should be provided, or 'average', 'highest' or 'lowest'",
+    ):
+        alg.GetArg("resolution").Set("invalid")
+
+    with pytest.raises(
+        Exception,
+        match="resolution: two comma separated positive values should be provided, or 'average', 'highest' or 'lowest'",
+    ):
+        alg.GetArg("resolution").Set("0.5")
+
+    with pytest.raises(
+        Exception,
+        match="resolution: two comma separated positive values should be provided, or 'average', 'highest' or 'lowest'",
+    ):
+        alg.GetArg("resolution").Set("-0.5,-0.5")
+
+
+def test_gdalalg_raster_buildvrt_srcnodata_vrtnodata():
+
+    src1_ds = gdal.GetDriverByName("MEM").Create("", 1, 1)
+    src1_ds.SetGeoTransform([2, 1, 0, 49, 0, -1])
+    src1_ds.GetRasterBand(1).Fill(1)
+
+    alg = get_buildvrt_alg()
+    alg.GetArg("input").Set([src1_ds])
+    alg.GetArg("output").Set("")
+    alg.GetArg("srcnodata").Set([1])
+    alg.GetArg("vrtnodata").Set([2])
+    assert alg.Run()
+    ds = alg.GetArg("output").Get().GetDataset()
+    assert ds.GetRasterBand(1).Checksum() == 2
+    assert ds.GetRasterBand(1).GetNoDataValue() == 2
+
+
+def test_gdalalg_raster_buildvrt_hidenodata():
+
+    src1_ds = gdal.GetDriverByName("MEM").Create("", 1, 1)
+    src1_ds.SetGeoTransform([2, 1, 0, 49, 0, -1])
+    src1_ds.GetRasterBand(1).Fill(1)
+
+    alg = get_buildvrt_alg()
+    alg.GetArg("input").Set([src1_ds])
+    alg.GetArg("output").Set("")
+    alg.GetArg("srcnodata").Set([1])
+    alg.GetArg("vrtnodata").Set([2])
+    alg.GetArg("hidenodata").Set(True)
+    assert alg.Run()
+    ds = alg.GetArg("output").Get().GetDataset()
+    assert ds.GetRasterBand(1).Checksum() == 2
+    assert ds.GetRasterBand(1).GetNoDataValue() is None
+
+
+def test_gdalalg_raster_buildvrt_addalpha():
+
+    alg = get_buildvrt_alg()
+    alg.GetArg("input").Set(["../gcore/data/byte.tif"])
+    alg.GetArg("output").Set("")
+    alg.GetArg("addalpha").Set(True)
+    assert alg.Run()
+    ds = alg.GetArg("output").Get().GetDataset()
+    assert ds.RasterCount == 2
+    assert ds.GetRasterBand(1).Checksum() == 4672
+    assert ds.GetRasterBand(2).GetColorInterpretation() == gdal.GCI_AlphaBand
+    assert ds.GetRasterBand(2).Checksum() == 4873
+
+
+def test_gdalalg_raster_buildvrt_band():
+
+    alg = get_buildvrt_alg()
+    alg.GetArg("input").Set(["../gcore/data/rgbsmall.tif"])
+    alg.GetArg("output").Set("")
+    alg.GetArg("band").Set([3, 2])
+    assert alg.Run()
+    ds = alg.GetArg("output").Get().GetDataset()
+    assert ds.RasterCount == 2
+    assert ds.GetRasterBand(1).Checksum() == 21349
+    assert ds.GetRasterBand(2).Checksum() == 21053
+
+
+def test_gdalalg_raster_buildvrt_glob():
+
+    alg = get_buildvrt_alg()
+    alg.GetArg("input").Set(["../gcore/data/rgbsm?ll.tif"])
+    alg.GetArg("output").Set("")
+    assert alg.Run()
+    ds = alg.GetArg("output").Get().GetDataset()
+    assert ds.RasterCount == 3
+
+
+def test_gdalalg_raster_buildvrt_at_filename(tmp_vsimem):
+
+    input_file_list = str(tmp_vsimem / "tmp.txt")
+    gdal.FileFromMemBuffer(input_file_list, "../gcore/data/byte.tif")
+
+    alg = get_buildvrt_alg()
+    alg.GetArg("input").Set([f"@{input_file_list}"])
+    alg.GetArg("output").Set("")
+    assert alg.Run()
+    ds = alg.GetArg("output").Get().GetDataset()
+    assert ds.GetRasterBand(1).Checksum() == 4672
+
+
+def test_gdalalg_raster_buildvrt_at_filename_error():
+
+    alg = get_buildvrt_alg()
+    alg.GetArg("input").Set(["@i_do_not_exist"])
+    alg.GetArg("output").Set("")
+    with pytest.raises(Exception, match="buildvrt: Cannot open i_do_not_exist"):
+        alg.Run()
+
+
+def test_gdalalg_raster_buildvrt_output_ds_alread_set():
+
+    out_ds = gdal.GetDriverByName("MEM").Create("", 1, 1)
+
+    alg = get_buildvrt_alg()
+    alg.GetArg("input").Set(["../gcore/data/byte.tif"])
+    alg.GetArg("output").Set(out_ds)
+    with pytest.raises(
+        Exception,
+        match="buildvrt: gdal raster buildvrt does not support outputting to an already opened output dataset",
+    ):
+        alg.Run()
+
+
+def test_gdalalg_raster_buildvrt_co():
+
+    alg = get_buildvrt_alg()
+    alg.GetArg("input").Set(["../gcore/data/byte.tif"])
+    alg.GetArg("output").Set("")
+    alg.GetArg("creation-option").Set(["BLOCKXSIZE=10", "BLOCKYSIZE=15"])
+    assert alg.Run()
+    ds = alg.GetArg("output").Get().GetDataset()
+    assert ds.GetRasterBand(1).GetBlockSize() == [10, 15]
diff --git a/autotest/utilities/test_gdalalg_raster_edit.py b/autotest/utilities/test_gdalalg_raster_edit.py
index a07ace225d29..d85556a8f36a 100755
--- a/autotest/utilities/test_gdalalg_raster_edit.py
+++ b/autotest/utilities/test_gdalalg_raster_edit.py
@@ -28,7 +28,7 @@ def test_gdalalg_raster_edit_read_only(tmp_vsimem):
     gdal.FileFromMemBuffer(tmp_filename, open("../gcore/data/byte.tif", "rb").read())
 
     pipeline = get_edit_alg()
-    pipeline.GetArg("dataset").Get().SetDataset(gdal.OpenEx(tmp_filename))
+    pipeline.GetArg("dataset").Set(gdal.OpenEx(tmp_filename))
     with pytest.raises(
         Exception, match="edit: Dataset should be opened in update mode"
     ):
diff --git a/doc/source/conf.py b/doc/source/conf.py
index 15d09859b36c..625663f20718 100644
--- a/doc/source/conf.py
+++ b/doc/source/conf.py
@@ -215,6 +215,13 @@
         [author_evenr],
         1,
     ),
+    (
+        "programs/gdal_raster_buildvrt",
+        "gdal-raster-buildvrt",
+        "Build a virtual dataset (VRT)",
+        [author_evenr],
+        1,
+    ),
     (
         "programs/gdal_raster_info",
         "gdal-raster-info",
diff --git a/doc/source/programs/gdal_raster.rst b/doc/source/programs/gdal_raster.rst
index 118bf2074caf..67cd7bd12fe1 100644
--- a/doc/source/programs/gdal_raster.rst
+++ b/doc/source/programs/gdal_raster.rst
@@ -19,6 +19,7 @@ Synopsis
 
     Usage: gdal raster <SUBCOMMAND>
     where <SUBCOMMAND> is one of:
+      - buildvrt:  Build a virtual dataset (VRT).
       - convert: Convert a raster dataset.
       - info:    Return information on a raster dataset.
       - pipeline:  Process a raster dataset.
@@ -27,6 +28,7 @@ Synopsis
 Available sub-commands
 ----------------------
 
+- :ref:`gdal_raster_buildvrt_subcommand`
 - :ref:`gdal_raster_info_subcommand`
 - :ref:`gdal_raster_convert_subcommand`
 - :ref:`gdal_raster_pipeline_subcommand`
diff --git a/doc/source/programs/gdal_raster_buildvrt.rst b/doc/source/programs/gdal_raster_buildvrt.rst
new file mode 100644
index 000000000000..ce29983e665f
--- /dev/null
+++ b/doc/source/programs/gdal_raster_buildvrt.rst
@@ -0,0 +1,181 @@
+.. _gdal_raster_buildvrt_subcommand:
+
+================================================================================
+"gdal raster buildvrt" sub-command
+================================================================================
+
+.. versionadded:: 3.11
+
+.. only:: html
+
+    Build a virtual dataset (VRT).
+
+.. Index:: gdal raster buildvrt
+
+Synopsis
+--------
+
+.. code-block::
+
+    Usage: gdal raster buildvrt [OPTIONS] <INPUTS> <OUTPUT>
+
+    Build a virtual dataset (VRT).
+
+    Positional arguments:
+      -i, --input <INPUTS>                                Input raster datasets (or specify a @<filename> to point to a file containing filenames) [1.. values]
+      -o, --output <OUTPUT>                               Output raster dataset (created by algorithm) [required]
+
+    Common Options:
+      -h, --help                                          Display help message and exit
+      --version                                           Display GDAL version and exit
+      --json-usage                                        Display usage as JSON document and exit
+      --drivers                                           Display driver list as JSON document and exit
+      --progress                                          Display progress bar
+
+    Options:
+      --co, --creation-option <KEY>=<VALUE>               Creation option [may be repeated]
+      -b, --band <BAND>                                   Specify input band(s) number. [may be repeated]
+      --separate                                          Place each input file into a separate band.
+      --overwrite                                         Whether overwriting existing output is allowed
+      --resolution <xres>,<yres>|average|highest|lowest>  Target resolution (in destination CRS units)
+      --bbox <xmin,ymin,xmax,ymax>                        Target bounding box (in destination CRS units)
+      --target-aligned-pixels                             Round target extent to target resolution
+      --srcnodata <SRCNODATA>                             Set nodata values for input bands. [1.. values]
+      --vrtnodata <VRTNODATA>                             Set nodata values at the VRT band level. [1.. values]
+      --hidenodata                                        Makes the VRT band not report the NoData.
+      --addalpha                                          Adds an alpha mask band to the VRT when the source raster have none.
+
+
+Description
+-----------
+
+This program builds a :ref:`VRT (Virtual Dataset) <raster.vrt>` that is a mosaic of a list of
+input GDAL datasets. The list of input GDAL datasets can be specified at the end
+of the command line or put in a text file (one filename per line) for very long lists.
+Wildcards '*', '?' or '['] of :cpp:func:`VSIGlob` can be used, even on files located
+on network file systems such as /vsis3/, /vsigs/, /vsiaz/, etc.
+
+With :option:`--separate`, each input goes into a separate band in the VRT dataset. Otherwise,
+the files are considered as source rasters of a larger mosaic and the VRT file has the same number of
+bands as the input files.
+
+If one GDAL dataset is made of several subdatasets and has 0 raster bands,
+all the subdatasets will be added to the VRT rather than the dataset itself.
+
+:program:`gdal raster buildvrt` does some checks to ensure that all files that will be put
+in the resulting VRT have similar characteristics: number of bands, projection, color
+interpretation, etc. If not, files that do not match the common characteristics will be skipped.
+(This is only true in the default mode, and not when using the :option:`--separate` option)
+
+If the inputs spatially overlap, the order of the input list is used to determine priority.
+Files that are listed at the end are the ones
+from which the content will be fetched. Note that nodata will be taken into account
+to potentially fetch data from lower-priority datasets, but currently, alpha channel
+is not taken into account to do alpha compositing (so a source with alpha=0
+appearing on top of another source will override its content). This might be
+changed in later versions.
+
+The following options are available:
+
+.. option:: -b <band>
+
+    Select an input <band> to be processed. Bands are numbered from 1.
+    If input bands not set all bands will be added to the VRT.
+    Multiple :option:`-b` switches may be used to select a set of input bands.
+
+.. option:: --separate
+
+    Place each input file into a separate band. See :example:`separate`.
+    Contrary to the default mode, it is not
+    required that all bands have the same datatype.
+
+    All bands of each input file are added as separate
+    VRT bands, unless :option:`-b` is specified to select a subset of them.
+
+.. option:: --resolution {<xres,yres>|highest|lowest|average}
+
+    In case the resolution of all input files is not the same, the :option:`--resolution` flag
+    enables the user to control the way the output resolution is computed.
+
+    `highest` will pick the smallest values of pixel dimensions within the set of source rasters.
+
+    `lowest` will pick the largest values of pixel dimensions within the set of source rasters.
+
+    `average` is the default and will compute an average of pixel dimensions within the set of source rasters.
+
+    <xres>,<yres>. The values must be expressed in georeferenced units.
+    Both must be positive values.
+
+.. option:: --bbox <xmin>,<ymin>,<xmax>,<ymax>
+
+    Set georeferenced extents of VRT file. The values must be expressed in georeferenced units.
+    If not specified, the extent of the VRT is the minimum bounding box of the set of source rasters.
+    Pixels within the extent of the VRT but not covered by a source raster will be read as valid
+    pixels with a value of zero unless a NODATA value is specified using :option:`--vrtnodata`
+    or an alpha mask band is added with :option:`--addalpha`.
+
+.. option:: --target-aligned-pixels
+
+    (target aligned pixels) align
+    the coordinates of the extent of the output file to the values of the :option:`--resolution`,
+    such that the aligned extent includes the minimum extent.
+    Alignment means that xmin / resx, ymin / resy, xmax / resx and ymax / resy are integer values.
+
+.. option:: --srcnodata <value>[,<value>]...
+
+    Set nodata values for input bands (different values can be supplied for each band).
+    If the option is not specified, the intrinsic nodata settings on the source datasets
+    will be used (if they exist). The value set by this option is written in the NODATA element
+    of each ``ComplexSource`` element.
+
+.. option:: --vrtnodata <value>[,<value>]...
+
+    Set nodata values at the VRT band level (different values can be supplied for each band).  If more
+    than one value is supplied, all values should be quoted to keep them together
+    as a single operating system argument (:example:`vrtnodata`). If the option is not specified,
+    intrinsic nodata settings on the first dataset will be used (if they exist). The value set by this option
+    is written in the ``NoDataValue`` element of each ``VRTRasterBand element``. Use a value of
+    `None` to ignore intrinsic nodata settings on the source datasets.
+
+.. option:: --addalpha
+
+    Adds an alpha mask band to the VRT when the source raster have none. Mainly useful for RGB sources (or grey-level sources).
+    The alpha band is filled on-the-fly with the value 0 in areas without any source raster, and with value
+    255 in areas with source raster. The effect is that a RGBA viewer will render
+    the areas without source rasters as transparent and areas with source rasters as opaque.
+    This option is not compatible with :option:`--separate`.
+
+.. option:: --hidenodata
+
+    Even if any band contains nodata value, giving this option makes the VRT band
+    not report the NoData. Useful when you want to control the background color of
+    the dataset. By using along with the -addalpha option, you can prepare a
+    dataset which doesn't report nodata value but is transparent in areas with no
+    data.
+
+
+Examples
+--------
+
+.. example::
+   :title: Make a RGB virtual mosaic from 3 single-band input files
+   :id: separate
+
+   .. code-block:: bash
+
+       gdal raster biuldvrt --separate red.tif green.tif blue.tif rgb.vrt
+
+.. example::
+   :title: Make a virtual mosaic with blue background colour (RGB: 0 0 255)
+   :id: vrtnodata
+
+   .. code-block:: bash
+
+       gdal raster buildvrt --hidenodata --vrtnodata=0,0,255 doq/*.tif doq_index.vrt
+
+
+.. below is an allow-list for spelling checker.
+
+.. spelling:word-list::
+    buildvrt
+
diff --git a/doc/source/programs/index.rst b/doc/source/programs/index.rst
index aa72042f6559..c2160d4b7ff5 100644
--- a/doc/source/programs/index.rst
+++ b/doc/source/programs/index.rst
@@ -29,6 +29,7 @@ single :program:`gdal` program that accepts commands and subcommands.
    gdal_info
    gdal_convert
    gdal_raster
+   gdal_raster_buildvrt
    gdal_raster_info
    gdal_raster_convert
    gdal_raster_edit
@@ -45,6 +46,7 @@ single :program:`gdal` program that accepts commands and subcommands.
     - :ref:`gdal_info_command`: Get information on a dataset
     - :ref:`gdal_convert_command`: Convert a dataset
     - :ref:`gdal_raster_command`: Entry point for raster commands
+    - :ref:`gdal_raster_buildvrt_subcommand`: buildvrt:  Build a virtual dataset (VRT)
     - :ref:`gdal_raster_info_subcommand`: Get information on a raster dataset
     - :ref:`gdal_raster_convert_subcommand`: Convert a raster dataset
     - :ref:`gdal_raster_edit_subcommand`: Edit in place a raster dataset
diff --git a/gcore/gdalalgorithm.cpp b/gcore/gdalalgorithm.cpp
index e86d90717c44..80b6e63a0839 100644
--- a/gcore/gdalalgorithm.cpp
+++ b/gcore/gdalalgorithm.cpp
@@ -1396,7 +1396,7 @@ bool GDALAlgorithm::ProcessDatasetArg(GDALAlgorithmArg *arg,
                     arg->GetName().c_str());
         ret = false;
     }
-    else if (!val.GetDatasetRef() &&
+    else if (!val.GetDatasetRef() && arg->AutoOpenDataset() &&
              (!arg->IsOutput() || (arg == outputArg && update && !overwrite)))
     {
         int flags = val.GetType();
@@ -1578,7 +1578,8 @@ bool GDALAlgorithm::ValidateArguments()
             }
         }
 
-        if (arg->IsExplicitlySet() && arg->GetType() == GAAT_DATASET_LIST)
+        if (arg->IsExplicitlySet() && arg->GetType() == GAAT_DATASET_LIST &&
+            arg->AutoOpenDataset())
         {
             auto &listVal = arg->Get<std::vector<GDALArgDatasetValue>>();
             for (auto &val : listVal)
@@ -3811,7 +3812,7 @@ bool GDALAlgorithmArgSetDataset(GDALAlgorithmArgH hArg, GDALDatasetH hDS)
  * Validation checks and other actions are run.
  *
  * @param hArg Handle to an argument. Must NOT be null.
- * @param value value (may be null)
+ * @param value value as a NULL terminated list (may be null)
  * @return true if success.
  * @since 3.11
  */
@@ -3867,6 +3868,54 @@ bool GDALAlgorithmArgSetAsDoubleList(GDALAlgorithmArgH hArg, size_t nCount,
     return hArg->ptr->Set(std::vector<double>(pnValues, pnValues + nCount));
 }
 
+/************************************************************************/
+/*                     GDALAlgorithmArgSetDatasets()                    */
+/************************************************************************/
+
+/** Set dataset objects to a GAAT_DATASET_LIST argument, increasing their reference counter.
+ *
+ * @param hArg Handle to an argument. Must NOT be null.
+ * @param nCount Number of values in pnValues.
+ * @param pahDS Pointer to an array of dataset of size nCount.
+ * @return true if success.
+ * @since 3.11
+ */
+
+bool GDALAlgorithmArgSetDatasets(GDALAlgorithmArgH hArg, size_t nCount,
+                                 GDALDatasetH *pahDS)
+{
+    VALIDATE_POINTER1(hArg, __func__, false);
+    std::vector<GDALArgDatasetValue> values;
+    for (size_t i = 0; i < nCount; ++i)
+    {
+        values.emplace_back(GDALDataset::FromHandle(pahDS[i]));
+    }
+    return hArg->ptr->Set(std::move(values));
+}
+
+/************************************************************************/
+/*                    GDALAlgorithmArgSetDatasetNames()                 */
+/************************************************************************/
+
+/** Set dataset names to a GAAT_DATASET_LIST argument.
+ *
+ * @param hArg Handle to an argument. Must NOT be null.
+ * @param names Dataset names as a NULL terminated list (may be null)
+ * @return true if success.
+ * @since 3.11
+ */
+
+bool GDALAlgorithmArgSetDatasetNames(GDALAlgorithmArgH hArg, CSLConstList names)
+{
+    VALIDATE_POINTER1(hArg, __func__, false);
+    std::vector<GDALArgDatasetValue> values;
+    for (size_t i = 0; names[i]; ++i)
+    {
+        values.emplace_back(names[i]);
+    }
+    return hArg->ptr->Set(std::move(values));
+}
+
 /************************************************************************/
 /*                      GDALArgDatasetValueCreate()                     */
 /************************************************************************/
diff --git a/gcore/gdalalgorithm.h b/gcore/gdalalgorithm.h
index cb7c50e782fb..3ae010ff68bf 100644
--- a/gcore/gdalalgorithm.h
+++ b/gcore/gdalalgorithm.h
@@ -194,6 +194,12 @@ bool CPL_DLL GDALAlgorithmArgSetAsDatasetValue(GDALAlgorithmArgH hArg,
 
 bool CPL_DLL GDALAlgorithmArgSetDataset(GDALAlgorithmArgH hArg, GDALDatasetH);
 
+bool CPL_DLL GDALAlgorithmArgSetDatasets(GDALAlgorithmArgH hArg, size_t nCount,
+                                         GDALDatasetH *);
+
+bool CPL_DLL GDALAlgorithmArgSetDatasetNames(GDALAlgorithmArgH hArg,
+                                             CSLConstList);
+
 bool CPL_DLL GDALAlgorithmArgSetAsInteger(GDALAlgorithmArgH, int);
 
 bool CPL_DLL GDALAlgorithmArgSetAsDouble(GDALAlgorithmArgH, double);
@@ -305,10 +311,7 @@ class GDALAlgorithmArg;
 
 /** Value for an argument that points to a GDALDataset.
  *
- * This is the value of arguments of type GAAT_DATASET, GAAT_RASTER_DATASET,
- * GAAT_VECTOR_DATASET, GAAT_MULTIDIM_DATASET, GAAT_DATASET_LIST,
- * GAAT_RASTER_DATASET_LIST, GAAT_VECTOR_DATASET_LIST,
- * GAAT_MULTIDIM_DATASET_LIST
+ * This is the value of arguments of type GAAT_DATASET or GAAT_DATASET_LIST.
  */
 class CPL_DLL GDALArgDatasetValue final
 {
@@ -741,6 +744,15 @@ class CPL_DLL GDALAlgorithmArgDecl final
         return *this;
     }
 
+    /** Sets whether the dataset should be opened automatically by
+     * GDALAlgorithm. Only applies to GAAT_DATASET and GAAT_DATASET_LIST.
+     */
+    GDALAlgorithmArgDecl &SetAutoOpenDataset(bool autoOpen)
+    {
+        m_autoOpenDataset = autoOpen;
+        return *this;
+    }
+
     /** Return the (long) name */
     inline const std::string &GetName() const
     {
@@ -921,6 +933,14 @@ class CPL_DLL GDALAlgorithmArgDecl final
         return m_removeSQLComments;
     }
 
+    /** Returns whether the dataset should be opened automatically by
+     * GDALAlgorithm. Only applies to GAAT_DATASET and GAAT_DATASET_LIST.
+     */
+    bool AutoOpenDataset() const
+    {
+        return m_autoOpenDataset;
+    }
+
     /** Get user-defined metadata. */
     inline const std::map<std::string, std::vector<std::string>>
     GetMetadata() const
@@ -944,14 +964,11 @@ class CPL_DLL GDALAlgorithmArgDecl final
      * - int for GAAT_INTEGER
      * - double for GAAT_REAL
      * - std::string for GAAT_STRING
-     * - GDALArgDatasetValue for GAAT_DATASET, GAAT_RASTER_DATASET,
-     *   GAAT_VECTOR_DATASET, GAAT_MULTIDIM_DATASET
+     * - GDALArgDatasetValue for GAAT_DATASET
      * - std::vector<int> for GAAT_INTEGER_LIST
      * - std::vector<double for GAAT_REAL_LIST
      * - std::vector<std::string> for GAAT_STRING_LIST
-     * - std::vector<GDALArgDatasetValue> for GAAT_DATASET_LIST,
-     *   GAAT_RASTER_DATASET_LIST, GAAT_VECTOR_DATASET_LIST,
-     *   GAAT_MULTIDIM_DATASET_LIST
+     * - std::vector<GDALArgDatasetValue> for GAAT_DATASET_LIST
      */
     template <class T> inline const T &GetDefault() const
     {
@@ -980,6 +997,7 @@ class CPL_DLL GDALAlgorithmArgDecl final
     bool m_displayHintAboutRepetition = true;
     bool m_readFromFileAtSyntaxAllowed = false;
     bool m_removeSQLComments = false;
+    bool m_autoOpenDataset = true;
     std::map<std::string, std::vector<std::string>> m_metadata{};
     std::vector<std::string> m_aliases{};
     std::vector<std::string> m_hiddenAliases{};
@@ -1183,6 +1201,12 @@ class CPL_DLL GDALAlgorithmArg /* non-final */
         return m_decl.GetDefault<T>();
     }
 
+    /** Alias for GDALAlgorithmArgDecl::AutoOpenDataset() */
+    inline bool AutoOpenDataset() const
+    {
+        return m_decl.AutoOpenDataset();
+    }
+
     /** Return the value of the argument, which is by decreasing order of priority:
      * - the value set through Set().
      * - the default value set through SetDefault().
@@ -1193,14 +1217,11 @@ class CPL_DLL GDALAlgorithmArg /* non-final */
      * - int for GAAT_INTEGER
      * - double for GAAT_REAL
      * - std::string for GAAT_STRING
-     * - GDALArgDatasetValue for GAAT_DATASET, GAAT_RASTER_DATASET,
-     *   GAAT_VECTOR_DATASET, GAAT_MULTIDIM_DATASET
+     * - GDALArgDatasetValue for GAAT_DATASET
      * - std::vector<int> for GAAT_INTEGER_LIST
      * - std::vector<double for GAAT_REAL_LIST
      * - std::vector<std::string> for GAAT_STRING_LIST
-     * - std::vector<GDALArgDatasetValue> for GAAT_DATASET_LIST,
-     *   GAAT_RASTER_DATASET_LIST, GAAT_VECTOR_DATASET_LIST,
-     *   GAAT_MULTIDIM_DATASET_LIST
+     * - std::vector<GDALArgDatasetValue> for GAAT_DATASET_LIST
      */
     template <class T> inline T &Get()
     {
@@ -1217,14 +1238,11 @@ class CPL_DLL GDALAlgorithmArg /* non-final */
      * - int for GAAT_INTEGER
      * - double for GAAT_REAL
      * - std::string for GAAT_STRING
-     * - GDALArgDatasetValue for GAAT_DATASET, GAAT_RASTER_DATASET,
-     *   GAAT_VECTOR_DATASET, GAAT_MULTIDIM_DATASET
+     * - GDALArgDatasetValue for GAAT_DATASET
      * - std::vector<int> for GAAT_INTEGER_LIST
      * - std::vector<double for GAAT_REAL_LIST
      * - std::vector<std::string> for GAAT_STRING_LIST
-     * - std::vector<GDALArgDatasetValue> for GAAT_DATASET_LIST,
-     *   GAAT_RASTER_DATASET_LIST, GAAT_VECTOR_DATASET_LIST,
-     *   GAAT_MULTIDIM_DATASET_LIST
+     * - std::vector<GDALArgDatasetValue> for GAAT_DATASET_LIST
      */
     template <class T> inline const T &Get() const
     {
@@ -1316,8 +1334,7 @@ class CPL_DLL GDALAlgorithmArg /* non-final */
      */
     bool Set(const std::vector<double> &value);
 
-    /** Set the value for a GAAT_DATASET_LIST, GAAT_RASTER_DATASET_LIST,
-     * GAAT_VECTOR_DATASET_LIST or GAAT_MULTIDIM_DATASET_LIST argument.
+    /** Set the value for a GAAT_DATASET_LIST argument.
      * It cannot be called several times for a given argument.
      * Validation checks and other actions are run.
      * Return true if success.
@@ -1548,6 +1565,13 @@ class CPL_DLL GDALInConstructionAlgorithmArg final : public GDALAlgorithmArg
         return *this;
     }
 
+    /** Alias for GDALAlgorithmArgDecl::SetAutoOpenDataset() */
+    GDALInConstructionAlgorithmArg &SetAutoOpenDataset(bool autoOpen)
+    {
+        m_decl.SetAutoOpenDataset(autoOpen);
+        return *this;
+    }
+
     /** Alias for GDALAlgorithmArgDecl::SetMutualExclusionGroup() */
     GDALInConstructionAlgorithmArg &
     SetMutualExclusionGroup(const std::string &group)
diff --git a/swig/include/Algorithm.i b/swig/include/Algorithm.i
index 25df9b898d86..8a07b9412bf8 100644
--- a/swig/include/Algorithm.i
+++ b/swig/include/Algorithm.i
@@ -223,9 +223,22 @@ public:
     return GDALAlgorithmArgSetAsDoubleList(self, nList, pList);
   }
 
-  void SetDataset(GDALDatasetShadow* ds) {
-    GDALAlgorithmArgSetDataset(self, ds);
+  bool SetDataset(GDALDatasetShadow* ds) {
+    return GDALAlgorithmArgSetDataset(self, ds);
+  }
+
+#if defined(SWIGPYTHON)
+  bool SetDatasets(int object_list_count, GDALDatasetShadow** poObjects) {
+    return GDALAlgorithmArgSetDatasets(self, object_list_count, poObjects);
   }
+#endif
+
+%apply (char **options) {char** names};
+  bool SetDatasetNames(char** names) {
+    return GDALAlgorithmArgSetDatasetNames(self, names);
+  }
+%clear char** names;
+
 }
 };
 
diff --git a/swig/include/python/gdal_python.i b/swig/include/python/gdal_python.i
index 9f50bb3b69de..c6385ad3bb4c 100644
--- a/swig/include/python/gdal_python.i
+++ b/swig/include/python/gdal_python.i
@@ -5206,13 +5206,23 @@ class VSIFile(BytesIO):
         if type == GAAT_REAL:
             return self.SetAsDouble(value)
         if type == GAAT_DATASET:
-            return self.SetAsDatasetValue(value)
+            if isinstance(value, str):
+                return self.GetAsDatasetValue().SetName(value)
+            elif isinstance(value, Dataset):
+                return self.GetAsDatasetValue().SetDataset(value)
+            else:
+                return self.SetAsDatasetValue(value)
         if type == GAAT_STRING_LIST:
             return self.SetAsStringList(value)
         if type == GAAT_INTEGER_LIST:
             return self.SetAsIntegerList(value)
         if type == GAAT_REAL_LIST:
             return self.SetAsDoubleList(value)
+        if type == GAAT_DATASET_LIST:
+            if isinstance(value[0], str):
+                return self.SetDatasetNames(value)
+            elif isinstance(value[0], Dataset):
+                return self.SetDatasets(value)
         raise Exception("Unhandled algorithm argument data type")
 
 %}

From dcea244819dc522fed26f5d18325ef14a2bb6ed4 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Wed, 1 Jan 2025 19:15:44 +0100
Subject: [PATCH 13/40] COG: fix TILING_SCHEME creation option type declaration
 to 'string-select'

---
 frmts/gtiff/cogdriver.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/frmts/gtiff/cogdriver.cpp b/frmts/gtiff/cogdriver.cpp
index ac56ca0d2845..6a3cb375970d 100644
--- a/frmts/gtiff/cogdriver.cpp
+++ b/frmts/gtiff/cogdriver.cpp
@@ -1545,7 +1545,7 @@ void GDALCOGDriver::InitializeCreationOptionList()
         "   </Option>"
         "  <Option name='OVERVIEW_COUNT' type='int' min='0' "
         "description='Number of overviews'/>"
-        "  <Option name='TILING_SCHEME' type='string' description='"
+        "  <Option name='TILING_SCHEME' type='string-select' description='"
         "Which tiling scheme to use pre-defined value or custom inline/outline "
         "JSON definition' default='CUSTOM'>"
         "    <Value>CUSTOM</Value>";

From 50ea83e7f2608847bee6a20d4166197f58b2f3a8 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Wed, 1 Jan 2025 19:41:58 +0100
Subject: [PATCH 14/40] Add CPLGetKnownConfigOptions()

---
 autotest/cpp/test_cpl.cpp |  4 ++++
 port/cpl_conv.cpp         | 20 ++++++++++++++++++++
 port/cpl_conv.h           |  1 +
 3 files changed, 25 insertions(+)

diff --git a/autotest/cpp/test_cpl.cpp b/autotest/cpp/test_cpl.cpp
index 046116e2fbb2..f20b16227e29 100644
--- a/autotest/cpp/test_cpl.cpp
+++ b/autotest/cpp/test_cpl.cpp
@@ -1319,6 +1319,10 @@ TEST_F(test_cpl, CPLDeclareKnownConfigOption)
     {
         CPLDeclareKnownConfigOption("DECLARED_OPTION", nullptr);
 
+        const CPLStringList aosKnownConfigOptions(CPLGetKnownConfigOptions());
+        EXPECT_GE(aosKnownConfigOptions.FindString("CPL_DEBUG"), 0);
+        EXPECT_GE(aosKnownConfigOptions.FindString("DECLARED_OPTION"), 0);
+
         CPLErrorStateBackuper oErrorStateBackuper(CPLQuietErrorHandler);
         CPLErrorReset();
         CPLConfigOptionSetter oDeclaredConfigOptionSetter("DECLARED_OPTION",
diff --git a/port/cpl_conv.cpp b/port/cpl_conv.cpp
index a3ace327d32e..af6920a18b6b 100644
--- a/port/cpl_conv.cpp
+++ b/port/cpl_conv.cpp
@@ -1961,6 +1961,26 @@ void CPLDeclareKnownConfigOption(const char *pszKey,
     goSetKnownConfigOptions.insert(CPLString(pszKey).toupper());
 }
 
+/************************************************************************/
+/*                       CPLGetKnownConfigOptions()                     */
+/************************************************************************/
+
+/** Return the list of known configuration options.
+ *
+ * Must be freed with CSLDestroy().
+ * @since 3.11
+ */
+char **CPLGetKnownConfigOptions()
+{
+    std::lock_guard oLock(goMutexDeclaredKnownConfigOptions);
+    CPLStringList aosList;
+    for (const char *pszKey : apszKnownConfigOptions)
+        aosList.AddString(pszKey);
+    for (const auto &osKey : goSetKnownConfigOptions)
+        aosList.AddString(osKey);
+    return aosList.StealList();
+}
+
 /************************************************************************/
 /*           CPLSetConfigOptionDetectUnknownConfigOption()              */
 /************************************************************************/
diff --git a/port/cpl_conv.h b/port/cpl_conv.h
index 8b715fe50782..1df8c48eff21 100644
--- a/port/cpl_conv.h
+++ b/port/cpl_conv.h
@@ -48,6 +48,7 @@ void CPL_DLL CPL_STDCALL CPLSetThreadLocalConfigOption(const char *pszKey,
                                                        const char *pszValue);
 void CPL_DLL CPLDeclareKnownConfigOption(const char *pszKey,
                                          const char *pszDefinition);
+char CPL_DLL **CPLGetKnownConfigOptions(void);
 
 /** Callback for CPLSubscribeToSetConfigOption() */
 typedef void (*CPLSetConfigOptionSubscriber)(const char *pszKey,

From d0a945c17fbf0322d0531e27b3f5fb845b5663fe Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Thu, 2 Jan 2025 00:15:41 +0100
Subject: [PATCH 15/40] GTiff creation option spec: add min/max to a number of
 integer options

---
 frmts/gtiff/geotiff.cpp | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/frmts/gtiff/geotiff.cpp b/frmts/gtiff/geotiff.cpp
index 877feb1dc7e7..c55460923edd 100644
--- a/frmts/gtiff/geotiff.cpp
+++ b/frmts/gtiff/geotiff.cpp
@@ -1350,7 +1350,7 @@ void GDALRegister_GTiff()
         osOptions +=
             ""
             "   <Option name='JPEG_QUALITY' type='int' description='JPEG "
-            "quality 1-100' default='75'/>"
+            "quality 1-100' min='1' max='100' default='75'/>"
             "   <Option name='JPEGTABLESMODE' type='int' description='Content "
             "of JPEGTABLES tag. 0=no JPEGTABLES tag, 1=Quantization tables "
             "only, 2=Huffman tables only, 3=Both' default='1'/>";
@@ -1367,23 +1367,24 @@ void GDALRegister_GTiff()
 #ifdef LIBDEFLATE_SUPPORT
         osOptions += ""
                      "   <Option name='ZLEVEL' type='int' description='DEFLATE "
-                     "compression level 1-12' default='6'/>";
+                     "compression level 1-12' min='1' max='12' default='6'/>";
 #else
         osOptions += ""
                      "   <Option name='ZLEVEL' type='int' description='DEFLATE "
-                     "compression level 1-9' default='6'/>";
+                     "compression level 1-9' min='1' max='9' default='6'/>";
 #endif
     }
     if (bHasLZMA)
         osOptions +=
             ""
             "   <Option name='LZMA_PRESET' type='int' description='LZMA "
-            "compression level 0(fast)-9(slow)' default='6'/>";
+            "compression level 0(fast)-9(slow)' min='0' max='9' default='6'/>";
     if (bHasZSTD)
         osOptions +=
             ""
             "   <Option name='ZSTD_LEVEL' type='int' description='ZSTD "
-            "compression level 1(fast)-22(slow)' default='9'/>";
+            "compression level 1(fast)-22(slow)' min='1' max='22' "
+            "default='9'/>";
     if (bHasLERC)
     {
         osOptions +=
@@ -1416,7 +1417,7 @@ void GDALRegister_GTiff()
         "   <Option name='JXL_LOSSLESS' type='boolean' description='Whether "
         "JPEGXL compression should be lossless' default='YES'/>"
         "   <Option name='JXL_EFFORT' type='int' description='Level of effort "
-        "1(fast)-9(slow)' default='5'/>"
+        "1(fast)-9(slow)' min='1' max='9' default='5'/>"
         "   <Option name='JXL_DISTANCE' type='float' description='Distance "
         "level for lossy compression (0=mathematically lossless, 1.0=visually "
         "lossless, usual range [0.5,3])' default='1.0' min='0.01' max='25.0'/>";

From 9335401148295a743eb4fda0cf2574f250b1bdec Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Thu, 2 Jan 2025 00:55:11 +0100
Subject: [PATCH 16/40] COG creation option spec: add min/max to a number of
 integer options

---
 frmts/gtiff/cogdriver.cpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/frmts/gtiff/cogdriver.cpp b/frmts/gtiff/cogdriver.cpp
index 6a3cb375970d..310204a64127 100644
--- a/frmts/gtiff/cogdriver.cpp
+++ b/frmts/gtiff/cogdriver.cpp
@@ -1481,10 +1481,12 @@ void GDALCOGDriver::InitializeCreationOptionList()
         osOptions += "   <Option name='QUALITY' type='int' "
                      "description='" +
                      osJPEG_WEBP +
-                     " quality 1-100' default='75'/>"
+                     " quality 1-100' min='1' max='100' default='75'/>"
                      "   <Option name='OVERVIEW_QUALITY' type='int' "
                      "description='Overview " +
-                     osJPEG_WEBP + " quality 1-100' default='75'/>";
+                     osJPEG_WEBP +
+                     " quality 1-100' min='1' max='100' "
+                     "default='75'/>";
     }
     if (bHasLERC)
     {
@@ -1502,7 +1504,7 @@ void GDALCOGDriver::InitializeCreationOptionList()
         "   <Option name='JXL_LOSSLESS' type='boolean' description='Whether "
         "JPEGXL compression should be lossless' default='YES'/>"
         "   <Option name='JXL_EFFORT' type='int' description='Level of effort "
-        "1(fast)-9(slow)' default='5'/>"
+        "1(fast)-9(slow)' min='1' max='9' default='5'/>"
         "   <Option name='JXL_DISTANCE' type='float' description='Distance "
         "level for lossy compression (0=mathematically lossless, 1.0=visually "
         "lossless, usual range [0.5,3])' default='1.0' min='0.01' max='25.0'/>";

From f239c6f90f2986bad51ae44523cc71c5733988b7 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Wed, 1 Jan 2025 16:59:23 +0100
Subject: [PATCH 17/40] gdal CLI: add Bash completion

Examples:
```
$ gdal <TAB><TAB>
convert   info      pipeline  raster    vector
```

```
$ gdal r<TAB>
==>
$ gdal raster
```

```
$ gdal raster<TAB><TAB>
convert    edit       info       pipeline   reproject
```

```
$ gdal raster info -<TAB><TAB>
--approx-stats   -f               --help           --if             --json-usage     --min-max        --no-fl          --no-md          --oo             --stats
--checksum       --format         --hist           --input          --list-mdd       --mm             --no-gcp         --no-nodata      --open-option    --subdataset
--drivers        -h               -i               --input-format   --mdd            --no-ct          --no-mask        --of             --output-format  --version
```

```
$ gdal raster info --of <TAB><TAB>
json  text
```

```
$ gdal raster info --of=<TAB><TAB>
json  text
```

```
$ gdal raster info --of=j<TAB>
==>
$ gdal raster info --of=json
```

```
$ gdal raster convert --of <TAB><TAB>
AAIGrid          CALS             ERS              GSAG             ILWIS            KEA              MFF              OpenFileGDB      R                SQLite           WMTS
ADRG             COG              EXR              GSBG             ISCE             KMLSUPEROVERLAY  MFF2             PAux             Rasterlite       SRTMHGT          XPM
AVIF             CTable2          FIT              GTA              ISIS2            KRO              MRF              PCIDSK           RMF              Terragen         XYZ
BAG              DDS              FITS             GTiff            ISIS3            KTX2             netCDF           PCRaster         ROI_PAC          TileDB           Zarr
BASISU           DTED             GeoRaster        GTX              JP2ECW           LAN              NGW              PDF              RRASTER          USGSDEM          ZMap
BLX              ECW              GIF              HDF4Image        JP2KAK           LCP              NITF             PDS4             RST              VICAR
BMP              EHdr             GPKG             HEIF             JP2OpenJPEG      Leveller         NTv2             PNG              SAGA             VRT
BT               ELAS             GRIB             HF2              JPEG             MBTiles          NULL             PNM              SGI              WEBP
BYN              ENVI             GS7BG            HFA              JPEGXL           MEM              NWT_GRD          PostGISRaster    SIGDEM           WMS
```

```
$ gdal raster convert in.tif out.tif --co <TAB><TAB>
ALPHA=                           ENDIANNESS=                      JXL_EFFORT=                      PIXELTYPE=                       SOURCE_PRIMARIES_RED=            TIFFTAG_TRANSFERRANGE_BLACK=
BIGTIFF=                         GEOTIFF_KEYS_FLAVOR=             JXL_LOSSLESS=                    PREDICTOR=                       SOURCE_WHITEPOINT=               TIFFTAG_TRANSFERRANGE_WHITE=
BLOCKXSIZE=                      GEOTIFF_VERSION=                 LZMA_PRESET=                     PROFILE=                         SPARSE_OK=                       TILED=
[ ... snip ... ]
```

```
$ gdal raster convert in.tif out.tif --co COMP<TAB>
==>
$ gdal raster convert in.tif out.tif --co COMPRESS=
```

```
$ gdal raster convert in.tif out.tif --co COMPRESS=<TAB><TAB>
CCITTFAX3     CCITTRLE      JPEG          LERC          LERC_ZSTD     LZW           PACKBITS      ZSTD
CCITTFAX4     DEFLATE       JXL           LERC_DEFLATE  LZMA          NONE          WEBP
```

```
$ gdal raster convert in.tif out.tif --co TILED=<TAB><TAB>
NO   YES
```

```
$ gdal raster convert in.tif out.tif --co ZLEVEL=<TAB><TAB>
1   10  11  12  2   3   4   5   6   7   8   9
```

```
$ gdal raster convert --of COG --co <TAB><TAB>
ADD_ALPHA=             EXTENT=                JXL_LOSSLESS=          NUM_THREADS=           OVERVIEW_RESAMPLING=   RESAMPLING=            WARP_RESAMPLING=
ALIGNED_LEVELS=        GEOTIFF_VERSION=       LEVEL=                 OVERVIEW_COMPRESS=     OVERVIEWS=             SPARSE_OK=             ZOOM_LEVEL=
BIGTIFF=               JXL_ALPHA_DISTANCE=    MAX_Z_ERROR=           OVERVIEW_COUNT=        PREDICTOR=             STATISTICS=            ZOOM_LEVEL_STRATEGY=
BLOCKSIZE=             JXL_DISTANCE=          MAX_Z_ERROR_OVERVIEW=  OVERVIEW_PREDICTOR=    QUALITY=               TARGET_SRS=
COMPRESS=              JXL_EFFORT=            NBITS=                 OVERVIEW_QUALITY=      RES=                   TILING_SCHEME=
```

```
$ gdal --config <TAB><TAB>
... long list of known configuration options ...
```

```
$ gdal --config AWS_<TAB><TAB>
AWS_ACCESS_KEY_ID=                       AWS_DEFAULT_REGION=                      AWS_REQUEST_PAYER=                       AWS_STS_ENDPOINT=
AWS_CONFIG_FILE=                         AWS_HTTPS=                               AWS_ROLE_ARN=                            AWS_STS_REGION=
AWS_CONTAINER_AUTHORIZATION_TOKEN=       AWS_MAX_KEYS=                            AWS_ROLE_SESSION_NAME=                   AWS_STS_REGIONAL_ENDPOINTS=
AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE=  AWS_NO_SIGN_REQUEST=                     AWS_S3_ENDPOINT=                         AWS_TIMESTAMP=
AWS_CONTAINER_CREDENTIALS_FULL_URI=      AWS_PROFILE=                             AWS_SECRET_ACCESS_KEY=                   AWS_VIRTUAL_HOSTING=
AWS_DEFAULT_PROFILE=                     AWS_REGION=                              AWS_SESSION_TOKEN=                       AWS_WEB_IDENTITY_TOKEN_FILE=
```

```
$ gdal raster reproject --dst-crs
EPSG:      ESRI:      IAU_2015:  IGNF:      NKG:       OGC:
```

```
$ gdal raster reproject --dst-crs EP<TAB>
==>
$ gdal raster reproject --dst-crs EPSG:
```

```
$ gdal raster reproject --dst-crs EPSG:<TAB>
10150 -- MSL UK & Ireland VORF08 depth
10151 -- CD UK & Ireland VORF08 depth
10156 -- ETRS89 + MSL UK & Ireland VORF08 depth
10157 -- ETRS89 + CD UK & Ireland VORF08 depth
[ ... snip ... ]
```

```
$ gdal raster reproject --dst-crs EPSG:432<TAB>
4322 -- WGS 72                  4324 -- WGS 72BE                4326 -- WGS 84                  4327 -- WGS 84 (geographic 3D)  4328 -- WGS 84 (geocentric)     4329 -- WGS 84 (3D)
```

Last but not least: autocompletion of VSI files
```
$ gdal raster info /vsis3/my_bucket/b<TAB><TAB>
/vsis3/my_bucket/byte.tif      /vsis3/my_bucket/byte2.tif
```
---
 apps/gdal.cpp                        |  88 ++-
 apps/gdalalg_abstract_pipeline.h     | 237 ++++++++
 apps/gdalalg_raster_pipeline.cpp     | 124 +---
 apps/gdalalg_raster_pipeline.h       |  25 +-
 apps/gdalalg_vector_pipeline.cpp     | 124 +---
 apps/gdalalg_vector_pipeline.h       |  25 +-
 autotest/cpp/test_gdal_algorithm.cpp |   8 +-
 autotest/utilities/test_gdal.py      | 305 ++++++++++
 gcore/gdalalgorithm.cpp              | 835 +++++++++++++++++++++++++--
 gcore/gdalalgorithm.h                |  62 +-
 scripts/completionFinder.py          |  37 +-
 scripts/gdal-bash-completion.sh      | 699 ++--------------------
 scripts/setdevenv.sh                 |   5 +
 13 files changed, 1564 insertions(+), 1010 deletions(-)
 create mode 100644 apps/gdalalg_abstract_pipeline.h

diff --git a/apps/gdal.cpp b/apps/gdal.cpp
index 88ea2e4dadce..9811118f18c0 100644
--- a/apps/gdal.cpp
+++ b/apps/gdal.cpp
@@ -17,12 +17,96 @@
 
 #include <cassert>
 
+// #define DEBUG_COMPLETION
+
+/************************************************************************/
+/*                           EmitCompletion()                           */
+/************************************************************************/
+
+/** Return on stdout a space-separated list of choices for bash completion */
+static void EmitCompletion(std::unique_ptr<GDALAlgorithm> rootAlg,
+                           const std::vector<std::string> &argsIn)
+{
+#ifdef DEBUG_COMPLETION
+    for (size_t i = 0; i < argsIn.size(); ++i)
+        fprintf(stderr, "arg[%d]='%s'\n", static_cast<int>(i),
+                argsIn[i].c_str());
+#endif
+
+    std::vector<std::string> args = argsIn;
+
+    std::string ret;
+    const auto addSpace = [&ret]()
+    {
+        if (!ret.empty())
+            ret += " ";
+    };
+
+    if (!args.empty() &&
+        (args.back() == "--config" ||
+         STARTS_WITH(args.back().c_str(), "--config=") ||
+         (args.size() >= 2 && args[args.size() - 2] == "--config")))
+    {
+        if (args.back() == "--config=" || args.back().back() != '=')
+        {
+            CPLStringList aosConfigOptions(CPLGetKnownConfigOptions());
+            for (const char *pszOpt : cpl::Iterate(aosConfigOptions))
+            {
+                addSpace();
+                ret += pszOpt;
+                ret += '=';
+            }
+            printf("%s", ret.c_str());
+        }
+        return;
+    }
+
+    // Get inner-most algorithm
+    bool showAllOptions = true;
+    auto curAlg = std::move(rootAlg);
+    while (!args.empty() && !args.front().empty() && args.front()[0] != '-')
+    {
+        auto subAlg = curAlg->InstantiateSubAlgorithm(args.front());
+        if (!subAlg)
+            break;
+        showAllOptions = false;
+        args.erase(args.begin());
+        curAlg = std::move(subAlg);
+    }
+
+    for (const auto &choice : curAlg->GetAutoComplete(args, showAllOptions))
+    {
+        addSpace();
+        ret += CPLString(choice).replaceAll(" ", "\\ ");
+    }
+
+#ifdef DEBUG_COMPLETION
+    fprintf(stderr, "ret = '%s'\n", ret.c_str());
+#endif
+    if (!ret.empty())
+        printf("%s", ret.c_str());
+}
+
 /************************************************************************/
 /*                                main()                                */
 /************************************************************************/
 
 MAIN_START(argc, argv)
 {
+    auto alg = GDALGlobalAlgorithmRegistry::GetSingleton().Instantiate(
+        GDALGlobalAlgorithmRegistry::ROOT_ALG_NAME);
+    assert(alg);
+
+    if (argc >= 3 && strcmp(argv[1], "completion") == 0)
+    {
+        GDALAllRegister();
+
+        // Process lines like "gdal completion gdal raster"
+        EmitCompletion(std::move(alg),
+                       std::vector<std::string>(argv + 3, argv + argc));
+        return 0;
+    }
+
     EarlySetConfigOptions(argc, argv);
 
     /* -------------------------------------------------------------------- */
@@ -31,14 +115,12 @@ MAIN_START(argc, argv)
     /* -------------------------------------------------------------------- */
 
     GDALAllRegister();
+
     argc = GDALGeneralCmdLineProcessor(
         argc, &argv, GDAL_OF_RASTER | GDAL_OF_VECTOR | GDAL_OF_MULTIDIM_RASTER);
     if (argc < 1)
         return (-argc);
 
-    auto alg = GDALGlobalAlgorithmRegistry::GetSingleton().Instantiate(
-        GDALGlobalAlgorithmRegistry::ROOT_ALG_NAME);
-    assert(alg);
     alg->SetCallPath(std::vector<std::string>{argv[0]});
     std::vector<std::string> args;
     for (int i = 1; i < argc; ++i)
diff --git a/apps/gdalalg_abstract_pipeline.h b/apps/gdalalg_abstract_pipeline.h
new file mode 100644
index 000000000000..36a0d0616681
--- /dev/null
+++ b/apps/gdalalg_abstract_pipeline.h
@@ -0,0 +1,237 @@
+/******************************************************************************
+ *
+ * Project:  GDAL
+ * Purpose:  gdal "raster/vector pipeline" subcommand
+ * Author:   Even Rouault <even dot rouault at spatialys.com>
+ *
+ ******************************************************************************
+ * Copyright (c) 2024, Even Rouault <even dot rouault at spatialys.com>
+ *
+ * SPDX-License-Identifier: MIT
+ ****************************************************************************/
+
+#ifndef GDALALG_ABSTRACT_PIPELINE_INCLUDED
+#define GDALALG_ABSTRACT_PIPELINE_INCLUDED
+
+//! @cond Doxygen_Suppress
+
+#include "cpl_conv.h"
+#include "cpl_json.h"
+#include "gdalalgorithm.h"
+
+template <class StepAlgorithm>
+class GDALAbstractPipelineAlgorithm CPL_NON_FINAL : public StepAlgorithm
+{
+  public:
+    std::vector<std::string> GetAutoComplete(std::vector<std::string> &args,
+                                             bool /* showAllOptions*/) override;
+
+    bool Finalize() override;
+
+    std::string GetUsageAsJSON() const override;
+
+    /* cppcheck-suppress functionStatic */
+    void SetDataset(GDALDataset *)
+    {
+    }
+
+  protected:
+    GDALAbstractPipelineAlgorithm(const std::string &name,
+                                  const std::string &description,
+                                  const std::string &helpURL,
+                                  bool standaloneStep)
+        : StepAlgorithm(name, description, helpURL, standaloneStep)
+    {
+    }
+
+    virtual GDALArgDatasetValue &GetOutputDataset() = 0;
+
+    std::string m_pipeline{};
+
+    std::unique_ptr<StepAlgorithm> GetStepAlg(const std::string &name) const;
+
+    GDALAlgorithmRegistry m_stepRegistry{};
+    std::vector<std::unique_ptr<StepAlgorithm>> m_steps{};
+
+  private:
+    bool RunStep(GDALProgressFunc pfnProgress, void *pProgressData) override;
+};
+
+/************************************************************************/
+/*              GDALAbstractPipelineAlgorithm::GetStepAlg()             */
+/************************************************************************/
+
+template <class StepAlgorithm>
+std::unique_ptr<StepAlgorithm>
+GDALAbstractPipelineAlgorithm<StepAlgorithm>::GetStepAlg(
+    const std::string &name) const
+{
+    auto alg = m_stepRegistry.Instantiate(name);
+    return std::unique_ptr<StepAlgorithm>(
+        cpl::down_cast<StepAlgorithm *>(alg.release()));
+}
+
+/************************************************************************/
+/*         GDALAbstractPipelineAlgorithm::GetAutoComplete()             */
+/************************************************************************/
+
+template <class StepAlgorithm>
+std::vector<std::string>
+GDALAbstractPipelineAlgorithm<StepAlgorithm>::GetAutoComplete(
+    std::vector<std::string> &args, bool /* showAllOptions*/)
+{
+    std::vector<std::string> ret;
+    if (args.size() <= 1)
+    {
+        ret.push_back("read");
+    }
+    else if (args.back() == "!" || args[args.size() - 2] == "!")
+    {
+        for (const std::string &name : m_stepRegistry.GetNames())
+        {
+            if (name != "read")
+            {
+                ret.push_back(name);
+            }
+        }
+    }
+    else
+    {
+        std::string lastStep = "read";
+        std::vector<std::string> lastArgs;
+        for (size_t i = 1; i < args.size(); ++i)
+        {
+            lastArgs.push_back(args[i]);
+            if (i + 1 < args.size() && args[i] == "!")
+            {
+                ++i;
+                lastArgs.clear();
+                lastStep = args[i];
+            }
+        }
+
+        auto curAlg = GetStepAlg(lastStep);
+        if (curAlg)
+        {
+            ret =
+                curAlg->GetAutoComplete(lastArgs, /* showAllOptions = */ false);
+        }
+    }
+    return ret;
+}
+
+/************************************************************************/
+/*              GDALAbstractPipelineAlgorithm::RunStep()                */
+/************************************************************************/
+
+template <class StepAlgorithm>
+bool GDALAbstractPipelineAlgorithm<StepAlgorithm>::RunStep(
+    GDALProgressFunc pfnProgress, void *pProgressData)
+{
+    if (m_steps.empty())
+    {
+        // If invoked programmatically, not from the command line.
+
+        if (m_pipeline.empty())
+        {
+            StepAlgorithm::ReportError(CE_Failure, CPLE_AppDefined,
+                                       "'pipeline' argument not set");
+            return false;
+        }
+
+        const CPLStringList aosTokens(CSLTokenizeString(m_pipeline.c_str()));
+        if (!this->ParseCommandLineArguments(aosTokens))
+            return false;
+    }
+
+    GDALDataset *poCurDS = nullptr;
+    for (size_t i = 0; i < m_steps.size(); ++i)
+    {
+        auto &step = m_steps[i];
+        if (i > 0)
+        {
+            if (step->m_inputDataset.GetDatasetRef())
+            {
+                // Shouldn't happen
+                StepAlgorithm::ReportError(
+                    CE_Failure, CPLE_AppDefined,
+                    "Step nr %d (%s) has already an input dataset",
+                    static_cast<int>(i), step->GetName().c_str());
+                return false;
+            }
+            step->m_inputDataset.Set(poCurDS);
+        }
+        if (i + 1 < m_steps.size() && step->m_outputDataset.GetDatasetRef())
+        {
+            // Shouldn't happen
+            StepAlgorithm::ReportError(
+                CE_Failure, CPLE_AppDefined,
+                "Step nr %d (%s) has already an output dataset",
+                static_cast<int>(i), step->GetName().c_str());
+            return false;
+        }
+        if (!step->Run(i < m_steps.size() - 1 ? nullptr : pfnProgress,
+                       i < m_steps.size() - 1 ? nullptr : pProgressData))
+        {
+            return false;
+        }
+        poCurDS = step->m_outputDataset.GetDatasetRef();
+        if (!poCurDS)
+        {
+            StepAlgorithm::ReportError(
+                CE_Failure, CPLE_AppDefined,
+                "Step nr %d (%s) failed to produce an output dataset",
+                static_cast<int>(i), step->GetName().c_str());
+            return false;
+        }
+    }
+
+    if (!GetOutputDataset().GetDatasetRef())
+    {
+        GetOutputDataset().Set(poCurDS);
+    }
+
+    return true;
+}
+
+/************************************************************************/
+/*               GDALAbstractPipelineAlgorithm::Finalize()              */
+/************************************************************************/
+
+template <class StepAlgorithm>
+bool GDALAbstractPipelineAlgorithm<StepAlgorithm>::Finalize()
+{
+    bool ret = GDALAlgorithm::Finalize();
+    for (auto &step : m_steps)
+    {
+        ret = step->Finalize() && ret;
+    }
+    return ret;
+}
+
+/************************************************************************/
+/*             GDALAbstractPipelineAlgorithm::GetUsageAsJSON()          */
+/************************************************************************/
+
+template <class StepAlgorithm>
+std::string GDALAbstractPipelineAlgorithm<StepAlgorithm>::GetUsageAsJSON() const
+{
+    CPLJSONDocument oDoc;
+    oDoc.LoadMemory(GDALAlgorithm::GetUsageAsJSON());
+
+    CPLJSONArray jPipelineSteps;
+    for (const std::string &name : m_stepRegistry.GetNames())
+    {
+        auto alg = GetStepAlg(name);
+        CPLJSONDocument oStepDoc;
+        oStepDoc.LoadMemory(alg->GetUsageAsJSON());
+        jPipelineSteps.Add(oStepDoc.GetRoot());
+    }
+    oDoc.GetRoot().Add("pipeline_algorithms", jPipelineSteps);
+
+    return oDoc.SaveAsString();
+}
+
+//! @endcond
+
+#endif
diff --git a/apps/gdalalg_raster_pipeline.cpp b/apps/gdalalg_raster_pipeline.cpp
index c135108959d5..0ab163fa531c 100644
--- a/apps/gdalalg_raster_pipeline.cpp
+++ b/apps/gdalalg_raster_pipeline.cpp
@@ -17,7 +17,6 @@
 #include "gdalalg_raster_write.h"
 
 #include "cpl_conv.h"
-#include "cpl_json.h"
 #include "cpl_string.h"
 
 #include <algorithm>
@@ -149,8 +148,9 @@ bool GDALRasterPipelineStepAlgorithm::RunImpl(GDALProgressFunc pfnProgress,
 
 GDALRasterPipelineAlgorithm::GDALRasterPipelineAlgorithm(
     bool openForMixedRasterVector)
-    : GDALRasterPipelineStepAlgorithm(NAME, DESCRIPTION, HELP_URL,
-                                      /*standaloneStep=*/false)
+    : GDALAbstractPipelineAlgorithm<GDALRasterPipelineStepAlgorithm>(
+          NAME, DESCRIPTION, HELP_URL,
+          /*standaloneStep=*/false)
 {
     AddInputArgs(openForMixedRasterVector, /* hiddenForCLI = */ true);
     AddProgressArg();
@@ -165,18 +165,6 @@ GDALRasterPipelineAlgorithm::GDALRasterPipelineAlgorithm(
     m_stepRegistry.Register<GDALRasterReprojectAlgorithm>();
 }
 
-/************************************************************************/
-/*              GDALRasterPipelineAlgorithm::GetStepAlg()               */
-/************************************************************************/
-
-std::unique_ptr<GDALRasterPipelineStepAlgorithm>
-GDALRasterPipelineAlgorithm::GetStepAlg(const std::string &name) const
-{
-    auto alg = m_stepRegistry.Instantiate(name);
-    return std::unique_ptr<GDALRasterPipelineStepAlgorithm>(
-        cpl::down_cast<GDALRasterPipelineStepAlgorithm *>(alg.release()));
-}
-
 /************************************************************************/
 /*       GDALRasterPipelineAlgorithm::ParseCommandLineArguments()       */
 /************************************************************************/
@@ -387,90 +375,6 @@ bool GDALRasterPipelineAlgorithm::ParseCommandLineArguments(
     return true;
 }
 
-/************************************************************************/
-/*               GDALRasterPipelineAlgorithm::RunStep()                 */
-/************************************************************************/
-
-bool GDALRasterPipelineAlgorithm::RunStep(GDALProgressFunc pfnProgress,
-                                          void *pProgressData)
-{
-    if (m_steps.empty())
-    {
-        // If invoked programmatically, not from the command line.
-
-        if (m_pipeline.empty())
-        {
-            ReportError(CE_Failure, CPLE_AppDefined,
-                        "'pipeline' argument not set");
-            return false;
-        }
-
-        const CPLStringList aosTokens(CSLTokenizeString(m_pipeline.c_str()));
-        if (!ParseCommandLineArguments(aosTokens))
-            return false;
-    }
-
-    GDALDataset *poCurDS = nullptr;
-    for (size_t i = 0; i < m_steps.size(); ++i)
-    {
-        auto &step = m_steps[i];
-        if (i > 0)
-        {
-            if (step->m_inputDataset.GetDatasetRef())
-            {
-                // Shouldn't happen
-                ReportError(CE_Failure, CPLE_AppDefined,
-                            "Step nr %d (%s) has already an input dataset",
-                            static_cast<int>(i), step->GetName().c_str());
-                return false;
-            }
-            step->m_inputDataset.Set(poCurDS);
-        }
-        if (i + 1 < m_steps.size() && step->m_outputDataset.GetDatasetRef())
-        {
-            // Shouldn't happen
-            ReportError(CE_Failure, CPLE_AppDefined,
-                        "Step nr %d (%s) has already an output dataset",
-                        static_cast<int>(i), step->GetName().c_str());
-            return false;
-        }
-        if (!step->Run(i < m_steps.size() - 1 ? nullptr : pfnProgress,
-                       i < m_steps.size() - 1 ? nullptr : pProgressData))
-        {
-            return false;
-        }
-        poCurDS = step->m_outputDataset.GetDatasetRef();
-        if (!poCurDS)
-        {
-            ReportError(CE_Failure, CPLE_AppDefined,
-                        "Step nr %d (%s) failed to produce an output dataset",
-                        static_cast<int>(i), step->GetName().c_str());
-            return false;
-        }
-    }
-
-    if (!m_outputDataset.GetDatasetRef())
-    {
-        m_outputDataset.Set(poCurDS);
-    }
-
-    return true;
-}
-
-/************************************************************************/
-/*                     GDALAlgorithm::Finalize()                        */
-/************************************************************************/
-
-bool GDALRasterPipelineAlgorithm::Finalize()
-{
-    bool ret = GDALAlgorithm::Finalize();
-    for (auto &step : m_steps)
-    {
-        ret = step->Finalize() && ret;
-    }
-    return ret;
-}
-
 /************************************************************************/
 /*            GDALRasterPipelineAlgorithm::GetUsageForCLI()             */
 /************************************************************************/
@@ -531,26 +435,4 @@ std::string GDALRasterPipelineAlgorithm::GetUsageForCLI(
     return ret;
 }
 
-/************************************************************************/
-/*             GDALRasterPipelineAlgorithm::GetUsageAsJSON()            */
-/************************************************************************/
-
-std::string GDALRasterPipelineAlgorithm::GetUsageAsJSON() const
-{
-    CPLJSONDocument oDoc;
-    oDoc.LoadMemory(GDALAlgorithm::GetUsageAsJSON());
-
-    CPLJSONArray jPipelineSteps;
-    for (const std::string &name : m_stepRegistry.GetNames())
-    {
-        auto alg = GetStepAlg(name);
-        CPLJSONDocument oStepDoc;
-        oStepDoc.LoadMemory(alg->GetUsageAsJSON());
-        jPipelineSteps.Add(oStepDoc.GetRoot());
-    }
-    oDoc.GetRoot().Add("pipeline_algorithms", jPipelineSteps);
-
-    return oDoc.SaveAsString();
-}
-
 //! @endcond
diff --git a/apps/gdalalg_raster_pipeline.h b/apps/gdalalg_raster_pipeline.h
index 0e0a35d86562..7129ac081908 100644
--- a/apps/gdalalg_raster_pipeline.h
+++ b/apps/gdalalg_raster_pipeline.h
@@ -14,6 +14,7 @@
 #define GDALALG_RASTER_PIPELINE_INCLUDED
 
 #include "gdalalgorithm.h"
+#include "gdalalg_abstract_pipeline.h"
 
 //! @cond Doxygen_Suppress
 
@@ -30,6 +31,7 @@ class GDALRasterPipelineStepAlgorithm /* non final */ : public GDALAlgorithm
                                     bool standaloneStep);
 
     friend class GDALRasterPipelineAlgorithm;
+    friend class GDALAbstractPipelineAlgorithm<GDALRasterPipelineStepAlgorithm>;
 
     virtual bool RunStep(GDALProgressFunc pfnProgress, void *pProgressData) = 0;
 
@@ -67,7 +69,8 @@ class GDALRasterPipelineStepAlgorithm /* non final */ : public GDALAlgorithm
 #define GDAL_PIPELINE_PROJ_NOSTALGIA
 #endif
 
-class GDALRasterPipelineAlgorithm final : public GDALRasterPipelineStepAlgorithm
+class GDALRasterPipelineAlgorithm final
+    : public GDALAbstractPipelineAlgorithm<GDALRasterPipelineStepAlgorithm>
 {
   public:
     static constexpr const char *NAME = "pipeline";
@@ -91,33 +94,19 @@ class GDALRasterPipelineAlgorithm final : public GDALRasterPipelineStepAlgorithm
     bool
     ParseCommandLineArguments(const std::vector<std::string> &args) override;
 
-    bool Finalize() override;
-
     std::string GetUsageForCLI(bool shortUsage,
                                const UsageOptions &usageOptions) const override;
 
-    std::string GetUsageAsJSON() const override;
-
     GDALDataset *GetDatasetRef()
     {
         return m_inputDataset.GetDatasetRef();
     }
 
-    /* cppcheck-suppress functionStatic */
-    void SetDataset(GDALDataset *)
+  protected:
+    GDALArgDatasetValue &GetOutputDataset() override
     {
+        return m_outputDataset;
     }
-
-  private:
-    std::string m_pipeline{};
-
-    bool RunStep(GDALProgressFunc pfnProgress, void *pProgressData) override;
-
-    std::unique_ptr<GDALRasterPipelineStepAlgorithm>
-    GetStepAlg(const std::string &name) const;
-
-    GDALAlgorithmRegistry m_stepRegistry{};
-    std::vector<std::unique_ptr<GDALRasterPipelineStepAlgorithm>> m_steps{};
 };
 
 //! @endcond
diff --git a/apps/gdalalg_vector_pipeline.cpp b/apps/gdalalg_vector_pipeline.cpp
index 6588ecaf6ad6..7bee6af9a19a 100644
--- a/apps/gdalalg_vector_pipeline.cpp
+++ b/apps/gdalalg_vector_pipeline.cpp
@@ -17,7 +17,6 @@
 #include "gdalalg_vector_write.h"
 
 #include "cpl_conv.h"
-#include "cpl_json.h"
 #include "cpl_string.h"
 
 #include <algorithm>
@@ -161,8 +160,9 @@ bool GDALVectorPipelineStepAlgorithm::RunImpl(GDALProgressFunc pfnProgress,
 /************************************************************************/
 
 GDALVectorPipelineAlgorithm::GDALVectorPipelineAlgorithm()
-    : GDALVectorPipelineStepAlgorithm(NAME, DESCRIPTION, HELP_URL,
-                                      /*standaloneStep=*/false)
+    : GDALAbstractPipelineAlgorithm<GDALVectorPipelineStepAlgorithm>(
+          NAME, DESCRIPTION, HELP_URL,
+          /*standaloneStep=*/false)
 {
     AddInputArgs(/* hiddenForCLI = */ true);
     AddProgressArg();
@@ -178,18 +178,6 @@ GDALVectorPipelineAlgorithm::GDALVectorPipelineAlgorithm()
     m_stepRegistry.Register<GDALVectorFilterAlgorithm>();
 }
 
-/************************************************************************/
-/*              GDALVectorPipelineAlgorithm::GetStepAlg()               */
-/************************************************************************/
-
-std::unique_ptr<GDALVectorPipelineStepAlgorithm>
-GDALVectorPipelineAlgorithm::GetStepAlg(const std::string &name) const
-{
-    auto alg = m_stepRegistry.Instantiate(name);
-    return std::unique_ptr<GDALVectorPipelineStepAlgorithm>(
-        cpl::down_cast<GDALVectorPipelineStepAlgorithm *>(alg.release()));
-}
-
 /************************************************************************/
 /*       GDALVectorPipelineAlgorithm::ParseCommandLineArguments()       */
 /************************************************************************/
@@ -444,90 +432,6 @@ bool GDALVectorPipelineAlgorithm::ParseCommandLineArguments(
     return true;
 }
 
-/************************************************************************/
-/*               GDALVectorPipelineAlgorithm::RunStep()                 */
-/************************************************************************/
-
-bool GDALVectorPipelineAlgorithm::RunStep(GDALProgressFunc pfnProgress,
-                                          void *pProgressData)
-{
-    if (m_steps.empty())
-    {
-        // If invoked programmatically, not from the command line.
-
-        if (m_pipeline.empty())
-        {
-            ReportError(CE_Failure, CPLE_AppDefined,
-                        "'pipeline' argument not set");
-            return false;
-        }
-
-        const CPLStringList aosTokens(CSLTokenizeString(m_pipeline.c_str()));
-        if (!ParseCommandLineArguments(aosTokens))
-            return false;
-    }
-
-    GDALDataset *poCurDS = nullptr;
-    for (size_t i = 0; i < m_steps.size(); ++i)
-    {
-        auto &step = m_steps[i];
-        if (i > 0)
-        {
-            if (step->m_inputDataset.GetDatasetRef())
-            {
-                // Shouldn't happen
-                ReportError(CE_Failure, CPLE_AppDefined,
-                            "Step nr %d (%s) has already an input dataset",
-                            static_cast<int>(i), step->GetName().c_str());
-                return false;
-            }
-            step->m_inputDataset.Set(poCurDS);
-        }
-        if (i + 1 < m_steps.size() && step->m_outputDataset.GetDatasetRef())
-        {
-            // Shouldn't happen
-            ReportError(CE_Failure, CPLE_AppDefined,
-                        "Step nr %d (%s) has already an output dataset",
-                        static_cast<int>(i), step->GetName().c_str());
-            return false;
-        }
-        if (!step->Run(i < m_steps.size() - 1 ? nullptr : pfnProgress,
-                       i < m_steps.size() - 1 ? nullptr : pProgressData))
-        {
-            return false;
-        }
-        poCurDS = step->m_outputDataset.GetDatasetRef();
-        if (!poCurDS)
-        {
-            ReportError(CE_Failure, CPLE_AppDefined,
-                        "Step nr %d (%s) failed to produce an output dataset",
-                        static_cast<int>(i), step->GetName().c_str());
-            return false;
-        }
-    }
-
-    if (!m_outputDataset.GetDatasetRef())
-    {
-        m_outputDataset.Set(poCurDS);
-    }
-
-    return true;
-}
-
-/************************************************************************/
-/*                     GDALAlgorithm::Finalize()                        */
-/************************************************************************/
-
-bool GDALVectorPipelineAlgorithm::Finalize()
-{
-    bool ret = GDALAlgorithm::Finalize();
-    for (auto &step : m_steps)
-    {
-        ret = step->Finalize() && ret;
-    }
-    return ret;
-}
-
 /************************************************************************/
 /*            GDALVectorPipelineAlgorithm::GetUsageForCLI()             */
 /************************************************************************/
@@ -592,26 +496,4 @@ std::string GDALVectorPipelineAlgorithm::GetUsageForCLI(
     return ret;
 }
 
-/************************************************************************/
-/*             GDALVectorPipelineAlgorithm::GetUsageAsJSON()            */
-/************************************************************************/
-
-std::string GDALVectorPipelineAlgorithm::GetUsageAsJSON() const
-{
-    CPLJSONDocument oDoc;
-    oDoc.LoadMemory(GDALAlgorithm::GetUsageAsJSON());
-
-    CPLJSONArray jPipelineSteps;
-    for (const std::string &name : m_stepRegistry.GetNames())
-    {
-        auto alg = GetStepAlg(name);
-        CPLJSONDocument oStepDoc;
-        oStepDoc.LoadMemory(alg->GetUsageAsJSON());
-        jPipelineSteps.Add(oStepDoc.GetRoot());
-    }
-    oDoc.GetRoot().Add("pipeline_algorithms", jPipelineSteps);
-
-    return oDoc.SaveAsString();
-}
-
 //! @endcond
diff --git a/apps/gdalalg_vector_pipeline.h b/apps/gdalalg_vector_pipeline.h
index 14b960dc6485..97564af4e04e 100644
--- a/apps/gdalalg_vector_pipeline.h
+++ b/apps/gdalalg_vector_pipeline.h
@@ -14,6 +14,7 @@
 #define GDALALG_VECTOR_PIPELINE_INCLUDED
 
 #include "gdalalgorithm.h"
+#include "gdalalg_abstract_pipeline.h"
 
 //! @cond Doxygen_Suppress
 
@@ -30,6 +31,7 @@ class GDALVectorPipelineStepAlgorithm /* non final */ : public GDALAlgorithm
                                     bool standaloneStep);
 
     friend class GDALVectorPipelineAlgorithm;
+    friend class GDALAbstractPipelineAlgorithm<GDALVectorPipelineStepAlgorithm>;
 
     virtual bool RunStep(GDALProgressFunc pfnProgress, void *pProgressData) = 0;
 
@@ -69,7 +71,8 @@ class GDALVectorPipelineStepAlgorithm /* non final */ : public GDALAlgorithm
 // "gdal vector pipeline ! read poly.gpkg ! reproject--dst-crs=EPSG:32632 ! write out.gpkg --overwrite"
 #define GDAL_PIPELINE_PROJ_NOSTALGIA
 
-class GDALVectorPipelineAlgorithm final : public GDALVectorPipelineStepAlgorithm
+class GDALVectorPipelineAlgorithm final
+    : public GDALAbstractPipelineAlgorithm<GDALVectorPipelineStepAlgorithm>
 {
   public:
     static constexpr const char *NAME = "pipeline";
@@ -93,28 +96,14 @@ class GDALVectorPipelineAlgorithm final : public GDALVectorPipelineStepAlgorithm
     bool
     ParseCommandLineArguments(const std::vector<std::string> &args) override;
 
-    bool Finalize() override;
-
     std::string GetUsageForCLI(bool shortUsage,
                                const UsageOptions &usageOptions) const override;
 
-    std::string GetUsageAsJSON() const override;
-
-    /* cppcheck-suppress functionStatic */
-    void SetDataset(GDALDataset *)
+  protected:
+    GDALArgDatasetValue &GetOutputDataset() override
     {
+        return m_outputDataset;
     }
-
-  private:
-    std::string m_pipeline{};
-
-    bool RunStep(GDALProgressFunc pfnProgress, void *pProgressData) override;
-
-    std::unique_ptr<GDALVectorPipelineStepAlgorithm>
-    GetStepAlg(const std::string &name) const;
-
-    GDALAlgorithmRegistry m_stepRegistry{};
-    std::vector<std::unique_ptr<GDALVectorPipelineStepAlgorithm>> m_steps{};
 };
 
 //! @endcond
diff --git a/autotest/cpp/test_gdal_algorithm.cpp b/autotest/cpp/test_gdal_algorithm.cpp
index 6174c5826c85..d8ca927ae20c 100644
--- a/autotest/cpp/test_gdal_algorithm.cpp
+++ b/autotest/cpp/test_gdal_algorithm.cpp
@@ -597,7 +597,13 @@ TEST_F(test_gdal_algorithm, GDALInConstructionAlgorithmArg_AddAlias)
 
     MyAlgorithm alg;
     alg.GetUsageForCLI(false);
+    EXPECT_NE(alg.GetArg("flag"), nullptr);
+    EXPECT_NE(alg.GetArg("--flag"), nullptr);
+    EXPECT_NE(alg.GetArg("-f"), nullptr);
+    EXPECT_NE(alg.GetArg("f"), nullptr);
     EXPECT_NE(alg.GetArg("alias"), nullptr);
+    EXPECT_EQ(alg.GetArg("invalid"), nullptr);
+    EXPECT_EQ(alg.GetArg("-"), nullptr);
 }
 
 TEST_F(test_gdal_algorithm, GDALInConstructionAlgorithmArg_AddAlias_redundant)
@@ -2919,7 +2925,7 @@ TEST_F(test_gdal_algorithm, algorithm_c_api)
 
     char **argNames = GDALAlgorithmGetArgNames(hAlg.get());
     ASSERT_NE(argNames, nullptr);
-    EXPECT_EQ(CSLCount(argNames), 12);
+    EXPECT_EQ(CSLCount(argNames), 13);
     CSLDestroy(argNames);
 
     EXPECT_EQ(GDALAlgorithmGetArg(hAlg.get(), "non_existing"), nullptr);
diff --git a/autotest/utilities/test_gdal.py b/autotest/utilities/test_gdal.py
index 420b6e9a0c98..6c7cf0546bae 100755
--- a/autotest/utilities/test_gdal.py
+++ b/autotest/utilities/test_gdal.py
@@ -17,6 +17,8 @@
 import pytest
 import test_cli_utilities
 
+from osgeo import gdal
+
 pytestmark = pytest.mark.skipif(
     test_cli_utilities.get_gdal_path() is None, reason="gdal binary not available"
 )
@@ -84,3 +86,306 @@ def test_gdal_failure_during_finalize(gdal_path):
         f"{gdal_path} raster convert ../gcore/data/byte.tif /vsimem/out.tif||maxlength=100"
     )
     assert "ret code = 1" in err
+
+
+def test_gdal_completion(gdal_path):
+
+    out = gdaltest.runexternal(f"{gdal_path} completion gdal -").split(" ")
+    assert "--version" in out
+
+    out = gdaltest.runexternal(f"{gdal_path} completion gdal").split(" ")
+    assert "convert" in out
+    assert "info" in out
+    assert "raster" in out
+    assert "vector" in out
+
+    out = gdaltest.runexternal(f"{gdal_path} completion gdal raster").split(" ")
+    assert "convert" in out
+    assert "edit" in out
+    assert "info" in out
+    assert "reproject" in out
+    assert "pipeline" in out
+
+    out = gdaltest.runexternal(f"{gdal_path} completion gdal raster info -").split(" ")
+    assert "-f" in out
+    assert "--of" in out
+    assert "--output-format" in out
+
+    out = gdaltest.runexternal(f"{gdal_path} completion gdal raster info --of").split(
+        " "
+    )
+    assert "json" in out
+    assert "text" in out
+
+    out = gdaltest.runexternal(f"{gdal_path} completion gdal raster info --of=").split(
+        " "
+    )
+    assert "json" in out
+    assert "text" in out
+
+    out = gdaltest.runexternal(f"{gdal_path} completion gdal raster info --of=t").split(
+        " "
+    )
+    assert "json" in out
+    assert "text" in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster convert --of"
+    ).split(" ")
+    if gdal.GetDriverByName("GTiff"):
+        assert "GTiff" in out
+    if gdal.GetDriverByName("HFA"):
+        assert "HFA" in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster convert --input"
+    ).split(" ")
+    assert "data/" in out or "data\\" in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster convert --input data/"
+    ).split(" ")
+    assert "data/whiteblackred.tif" in out or "data\\whiteblackred.tif" in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster convert /vsizip/../gcore/data/byte.tif.zip/"
+    ).split(" ")
+    assert out == ["/vsizip/../gcore/data/byte.tif.zip/byte.tif"]
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster reproject --resolution"
+    )
+    assert (
+        out
+        == "** description:\\ Target\\ resolution\\ (in\\ destination\\ CRS\\ units)"
+    )
+
+
+def test_gdal_completion_co(gdal_path):
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster convert in.tif out.tif --co"
+    ).split(" ")
+    assert "COMPRESS=" in out
+    assert "RPCTXT=" in out
+    assert "TILING_SCHEME=" not in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster convert in.tif out.tif --co="
+    ).split(" ")
+    assert "COMPRESS=" in out
+    assert "RPCTXT=" in out
+    assert "TILING_SCHEME=" not in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster convert in.tif out.tif --co COMPRESS="
+    ).split(" ")
+    assert "NONE" in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster convert in.tif out.tif --co COMPRESS=NO"
+    ).split(" ")
+    assert "NONE" in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster convert in.tif out.tif --co=COMPRESS="
+    ).split(" ")
+    assert "NONE" in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster convert in.tif out.tif --co=COMPRESS=NO"
+    ).split(" ")
+    assert "NONE" in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster convert in.tif out.tif --co TILED="
+    ).split(" ")
+    assert out == ["NO", "YES"]
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster convert in.tif out.tif --co ZLEVEL="
+    ).split(" ")
+    assert "1" in out
+    assert "9" in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster convert --of COG --co="
+    ).split(" ")
+    assert "COMPRESS=" in out
+    assert "RPCTXT=" not in out
+    assert "TILING_SCHEME=" in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster convert --of=COG --creation-option ZOOM_LEVEL="
+    )
+    assert (
+        out
+        == "## type:\\ int,\\ description:\\ Target\\ zoom\\ level.\\ Only\\ used\\ for\\ TILING_SCHEME\\ !=\\ CUSTOM"
+    )
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster convert --of COG --co BLOCKSIZE="
+    )
+    assert out == "## validity\\ range:\\ >=\\ 128"
+
+    if "JPEG_QUALITY" in gdal.GetDriverByName("GTiff").GetMetadataItem(
+        "DMD_CREATIONOPTIONLIST"
+    ):
+        out = gdaltest.runexternal(
+            f"{gdal_path} completion gdal raster convert in.tif out.tif --co JPEG_QUALITY="
+        )
+        assert out == "## validity\\ range:\\ [1,100]"
+
+    if gdal.GetDriverByName("GPKG"):
+        out = gdaltest.runexternal(
+            f"{gdal_path} completion gdal raster convert --of GPKG --co="
+        ).split(" ")
+        assert "APPEND_SUBDATASET=" in out
+        assert "VERSION=" in out
+
+        out = gdaltest.runexternal(
+            f"{gdal_path} completion gdal vector convert --of GPKG --co="
+        ).split(" ")
+        assert "APPEND_SUBDATASET=" not in out
+        assert "VERSION=" in out
+
+        out = gdaltest.runexternal(
+            f"{gdal_path} completion gdal raster convert --of GPKG --co BLOCKSIZE="
+        )
+        assert out == "## validity\\ range:\\ <=\\ 4096"
+
+
+def test_gdal_completion_lco(gdal_path):
+
+    if gdal.GetDriverByName("GPKG"):
+
+        out = gdaltest.runexternal(
+            f"{gdal_path} completion gdal vector convert --of GPKG --lco"
+        ).split(" ")
+        assert "FID=" in out
+
+        out = gdaltest.runexternal(
+            f"{gdal_path} completion gdal vector convert in.shp out.gpkg --layer-creation-option="
+        ).split(" ")
+        assert "FID=" in out
+
+
+def test_gdal_completion_oo(gdal_path):
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster info foo.tif --oo"
+    ).split(" ")
+    assert "COLOR_TABLE_MULTIPLIER=" in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster info --if GTiff --open-option"
+    ).split(" ")
+    assert "COLOR_TABLE_MULTIPLIER=" in out
+
+
+def test_gdal_completion_dst_crs(gdal_path):
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster reproject --dst-crs"
+    ).split(" ")
+    assert "EPSG:" in out
+    assert "ESRI:" in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster reproject --dst-crs EPSG:"
+    )
+    assert "4326\\ --\\ WGS\\ 84" in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster reproject --dst-crs=EPSG:"
+    )
+    assert "4326\\ --\\ WGS\\ 84" in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster reproject --dst-crs EPSG:43"
+    )
+    assert "4326\\ --\\ WGS\\ 84" in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster reproject --dst-crs=EPSG:43"
+    )
+    assert "4326\\ --\\ WGS\\ 84" in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster reproject --dst-crs EPSG:4326"
+    )
+    assert out == "4326"
+
+
+def test_gdal_completion_config(gdal_path):
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster convert --config"
+    ).split(" ")
+    assert "CPL_DEBUG=" in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster convert --config="
+    ).split(" ")
+    assert "CPL_DEBUG=" in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster convert --config FOO="
+    ).split(" ")
+    assert out == [""]
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal raster convert --config=FOO="
+    ).split(" ")
+    assert out == [""]
+
+
+@pytest.mark.parametrize("subcommand", ["raster", "vector"])
+def test_gdal_completion_pipeline(gdal_path, subcommand):
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal {subcommand} pipeline"
+    ).split(" ")
+    assert out == ["read"]
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal {subcommand} pipeline re"
+    ).split(" ")
+    assert out == ["read"]
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal {subcommand} pipeline read -"
+    ).split(" ")
+    assert "--input" in out
+    assert "--open-option" in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal {subcommand} pipeline read !"
+    ).split(" ")
+    assert "reproject" in out
+    assert "write" in out
+    assert "read" not in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal {subcommand} pipeline read ! re"
+    ).split(" ")
+    assert "reproject" in out
+    assert "write" in out
+    assert "read" not in out
+
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal {subcommand} pipeline read foo ! write -"
+    ).split(" ")
+    assert "--output" in out
+    assert "--co" in out
+
+    if subcommand == "raster":
+        out = gdaltest.runexternal(
+            f"{gdal_path} completion gdal {subcommand} pipeline read foo ! foo ! reproject -"
+        ).split(" ")
+        assert "--resampling" in out
+
+        out = gdaltest.runexternal(
+            f"{gdal_path} completion gdal {subcommand} pipeline read foo ! reproject --resampling"
+        ).split(" ")
+        assert "near" in out
diff --git a/gcore/gdalalgorithm.cpp b/gcore/gdalalgorithm.cpp
index e86d90717c44..1026d14aebb7 100644
--- a/gcore/gdalalgorithm.cpp
+++ b/gcore/gdalalgorithm.cpp
@@ -14,6 +14,7 @@
 #include "cpl_conv.h"
 #include "cpl_error.h"
 #include "cpl_json.h"
+#include "cpl_minixml.h"
 
 #include "gdalalgorithm.h"
 #include "gdal_priv.h"
@@ -28,6 +29,12 @@
 #define _(x) (x)
 #endif
 
+constexpr const char *GDAL_ARG_NAME_INPUT_FORMAT = "input-format";
+
+constexpr const char *GDAL_ARG_NAME_OUTPUT_FORMAT = "output-format";
+
+constexpr const char *GDAL_ARG_NAME_OPEN_OPTION = "open-option";
+
 //! @cond Doxygen_Suppress
 struct GDALAlgorithmArgHS
 {
@@ -712,7 +719,7 @@ GDALInConstructionAlgorithmArg::SetIsCRSArg(bool noneAllowed)
                  "SetIsCRSArg() can only be called on a String argument");
         return *this;
     }
-    return AddValidationAction(
+    AddValidationAction(
         [this, noneAllowed]()
         {
             const std::string &osVal =
@@ -731,6 +738,57 @@ GDALInConstructionAlgorithmArg::SetIsCRSArg(bool noneAllowed)
             }
             return true;
         });
+
+    SetAutoCompleteFunction(
+        [](const std::string &currentValue)
+        {
+            std::vector<std::string> oRet;
+            if (!currentValue.empty())
+            {
+                const CPLStringList aosTokens(
+                    CSLTokenizeString2(currentValue.c_str(), ":", 0));
+                int nCount = 0;
+                OSRCRSInfo **pCRSList = OSRGetCRSInfoListFromDatabase(
+                    aosTokens[0], nullptr, &nCount);
+                std::string osCode;
+                for (int i = 0; i < nCount; ++i)
+                {
+                    if (aosTokens.size() == 1 ||
+                        STARTS_WITH(pCRSList[i]->pszCode, aosTokens[1]))
+                    {
+                        if (oRet.empty())
+                            osCode = pCRSList[i]->pszCode;
+                        oRet.push_back(std::string(pCRSList[i]->pszCode)
+                                           .append(" -- ")
+                                           .append(pCRSList[i]->pszName));
+                    }
+                }
+                if (oRet.size() == 1)
+                {
+                    // If there is a single match, remove the name from the suggestion.
+                    oRet.clear();
+                    oRet.push_back(osCode);
+                }
+                OSRDestroyCRSInfoList(pCRSList);
+            }
+            if (oRet.empty())
+            {
+                const CPLStringList aosAuthorities(
+                    OSRGetAuthorityListFromDatabase());
+                for (const char *pszAuth : cpl::Iterate(aosAuthorities))
+                {
+                    int nCount = 0;
+                    OSRCRSInfo **pCRSList = OSRGetCRSInfoListFromDatabase(
+                        pszAuth, nullptr, &nCount);
+                    OSRDestroyCRSInfoList(pCRSList);
+                    if (nCount)
+                        oRet.push_back(std::string(pszAuth).append(":"));
+                }
+            }
+            return oRet;
+        });
+
+    return *this;
 }
 
 /************************************************************************/
@@ -761,6 +819,10 @@ GDALAlgorithm::GDALAlgorithm(const std::string &name,
            &m_dummyBoolean)
         .SetOnlyForCLI()
         .SetCategory(GAAC_COMMON);
+    AddArg("config", 0, _("Configuration option"), &m_dummyConfigOptions)
+        .SetMetaVar("<KEY>=<VALUE>")
+        .SetOnlyForCLI()
+        .SetCategory(GAAC_COMMON);
 }
 
 /************************************************************************/
@@ -1150,6 +1212,11 @@ bool GDALAlgorithm::ParseCommandLineArguments(
         {
             if (i + 1 == lArgs.size())
             {
+                if (m_parseForAutoCompletion)
+                {
+                    lArgs.erase(lArgs.begin() + i);
+                    break;
+                }
                 ReportError(
                     CE_Failure, CPLE_IllegalArg,
                     "Expected value for argument '%s', but ran short of tokens",
@@ -1171,6 +1238,47 @@ bool GDALAlgorithm::ParseCommandLineArguments(
         return true;
     }
 
+    const auto ProcessInConstructionValues = [&inConstructionValues]()
+    {
+        for (auto &[arg, value] : inConstructionValues)
+        {
+            if (arg->GetType() == GAAT_STRING_LIST)
+            {
+                if (!arg->Set(std::get<std::vector<std::string>>(
+                        inConstructionValues[arg])))
+                {
+                    return false;
+                }
+            }
+            else if (arg->GetType() == GAAT_INTEGER_LIST)
+            {
+                if (!arg->Set(
+                        std::get<std::vector<int>>(inConstructionValues[arg])))
+                {
+                    return false;
+                }
+            }
+            else if (arg->GetType() == GAAT_REAL_LIST)
+            {
+                if (!arg->Set(std::get<std::vector<double>>(
+                        inConstructionValues[arg])))
+                {
+                    return false;
+                }
+            }
+            else if (arg->GetType() == GAAT_DATASET_LIST)
+            {
+                if (!arg->Set(
+                        std::move(std::get<std::vector<GDALArgDatasetValue>>(
+                            inConstructionValues[arg]))))
+                {
+                    return false;
+                }
+            }
+        }
+        return true;
+    };
+
     size_t i = 0;
     size_t iCurPosArg = 0;
     while (i < lArgs.size() && iCurPosArg < m_positionalArgs.size())
@@ -1209,6 +1317,7 @@ bool GDALAlgorithm::ParseCommandLineArguments(
                                 "varying number of values",
                                 otherArg->GetName().c_str(),
                                 arg->GetName().c_str());
+                            ProcessInConstructionValues();
                             return false;
                         }
                         nCountAtEnd += otherArg->GetMinCount();
@@ -1226,6 +1335,7 @@ bool GDALAlgorithm::ParseCommandLineArguments(
                                 "values",
                                 otherArg->GetName().c_str(),
                                 arg->GetName().c_str());
+                            ProcessInConstructionValues();
                             return false;
                         }
                         nCountAtEnd++;
@@ -1235,6 +1345,7 @@ bool GDALAlgorithm::ParseCommandLineArguments(
                 {
                     ReportError(CE_Failure, CPLE_AppDefined,
                                 "Not enough positional values.");
+                    ProcessInConstructionValues();
                     return false;
                 }
                 for (; i < lArgs.size() - nCountAtEnd; ++i)
@@ -1242,6 +1353,7 @@ bool GDALAlgorithm::ParseCommandLineArguments(
                     if (!ParseArgument(arg, arg->GetName().c_str(), lArgs[i],
                                        inConstructionValues))
                     {
+                        ProcessInConstructionValues();
                         return false;
                     }
                 }
@@ -1253,6 +1365,7 @@ bool GDALAlgorithm::ParseCommandLineArguments(
                     if (!ParseArgument(arg, arg->GetName().c_str(), lArgs[i],
                                        inConstructionValues))
                     {
+                        ProcessInConstructionValues();
                         return false;
                     }
                 }
@@ -1279,7 +1392,10 @@ bool GDALAlgorithm::ParseCommandLineArguments(
             {
                 if (!ParseArgument(arg, arg->GetName().c_str(), lArgs[i],
                                    inConstructionValues))
+                {
+                    ProcessInConstructionValues();
                     return false;
+                }
             }
         }
         ++iCurPosArg;
@@ -1290,6 +1406,7 @@ bool GDALAlgorithm::ParseCommandLineArguments(
         ReportError(CE_Failure, CPLE_AppDefined,
                     "Positional values starting at '%s' are not expected.",
                     lArgs[i].c_str());
+        ProcessInConstructionValues();
         return false;
     }
     if (iCurPosArg < m_positionalArgs.size() &&
@@ -1308,47 +1425,13 @@ bool GDALAlgorithm::ParseCommandLineArguments(
                         "Positional arguments starting at '%s' have not been "
                         "specified.",
                         m_positionalArgs[iCurPosArg]->GetMetaVar().c_str());
+            ProcessInConstructionValues();
             return false;
         }
     }
 
-    for (auto &[arg, value] : inConstructionValues)
-    {
-        if (arg->GetType() == GAAT_STRING_LIST)
-        {
-            if (!arg->Set(std::get<std::vector<std::string>>(
-                    inConstructionValues[arg])))
-            {
-                return false;
-            }
-        }
-        else if (arg->GetType() == GAAT_INTEGER_LIST)
-        {
-            if (!arg->Set(
-                    std::get<std::vector<int>>(inConstructionValues[arg])))
-            {
-                return false;
-            }
-        }
-        else if (arg->GetType() == GAAT_REAL_LIST)
-        {
-            if (!arg->Set(
-                    std::get<std::vector<double>>(inConstructionValues[arg])))
-            {
-                return false;
-            }
-        }
-        else if (arg->GetType() == GAAT_DATASET_LIST)
-        {
-            if (!arg->Set(std::move(std::get<std::vector<GDALArgDatasetValue>>(
-                    inConstructionValues[arg]))))
-            {
-                return false;
-            }
-        }
-    }
-
-    return m_skipValidationInParseCommandLine || ValidateArguments();
+    return ProcessInConstructionValues() &&
+           (m_skipValidationInParseCommandLine || ValidateArguments());
 }
 
 /************************************************************************/
@@ -1426,12 +1509,12 @@ bool GDALAlgorithm::ProcessDatasetArg(GDALAlgorithmArg *arg,
         CPLStringList aosAllowedDrivers;
         if (arg->GetName() == GDAL_ARG_NAME_INPUT)
         {
-            const auto ooArg = GetArg("open-option");
+            const auto ooArg = GetArg(GDAL_ARG_NAME_OPEN_OPTION);
             if (ooArg && ooArg->GetType() == GAAT_STRING_LIST)
                 aosOpenOptions =
                     CPLStringList(ooArg->Get<std::vector<std::string>>());
 
-            const auto ifArg = GetArg("input-format");
+            const auto ifArg = GetArg(GDAL_ARG_NAME_INPUT_FORMAT);
             if (ifArg && ifArg->GetType() == GAAT_STRING_LIST)
                 aosAllowedDrivers =
                     CPLStringList(ifArg->Get<std::vector<std::string>>());
@@ -1599,14 +1682,14 @@ bool GDALAlgorithm::ValidateArguments()
                     CPLStringList aosAllowedDrivers;
                     if (arg->GetName() == GDAL_ARG_NAME_INPUT)
                     {
-                        const auto ooArg = GetArg("open-option");
+                        const auto ooArg = GetArg(GDAL_ARG_NAME_OPEN_OPTION);
                         if (ooArg && ooArg->GetType() == GAAT_STRING_LIST)
                         {
                             aosOpenOptions = CPLStringList(
                                 ooArg->Get<std::vector<std::string>>());
                         }
 
-                        const auto ifArg = GetArg("input-format");
+                        const auto ifArg = GetArg(GDAL_ARG_NAME_INPUT_FORMAT);
                         if (ifArg && ifArg->GetType() == GAAT_STRING_LIST)
                         {
                             aosAllowedDrivers = CPLStringList(
@@ -1639,6 +1722,29 @@ bool GDALAlgorithm::ValidateArguments()
     return ret;
 }
 
+/************************************************************************/
+/*                      GDALAlgorithm::GetArg()                         */
+/************************************************************************/
+
+const GDALAlgorithmArg *GDALAlgorithm::GetArg(const std::string &osName) const
+{
+    const auto nPos = osName.find_first_not_of('-');
+    if (nPos == std::string::npos)
+        return nullptr;
+    const std::string osKey = osName.substr(nPos);
+    {
+        const auto oIter = m_mapLongNameToArg.find(osKey);
+        if (oIter != m_mapLongNameToArg.end())
+            return oIter->second;
+    }
+    {
+        const auto oIter = m_mapShortNameToArg.find(osKey);
+        if (oIter != m_mapShortNameToArg.end())
+            return oIter->second;
+    }
+    return nullptr;
+}
+
 /************************************************************************/
 /*                   GDALAlgorithm::AddAliasFor()                       */
 /************************************************************************/
@@ -1847,6 +1953,77 @@ GDALAlgorithm::AddInputDatasetArg(GDALArgDatasetValue *pValue,
                        pValue, type);
     if (positionalAndRequired)
         arg.SetPositional().SetRequired();
+
+    arg.SetAutoCompleteFunction(
+        [type](const std::string &currentValue)
+        {
+            std::vector<std::string> oRet;
+
+            auto poDM = GetGDALDriverManager();
+            std::set<std::string> oExtensions;
+            for (int i = 0; i < poDM->GetDriverCount(); ++i)
+            {
+                auto poDriver = poDM->GetDriver(i);
+                if (((type & GDAL_OF_RASTER) != 0 &&
+                     poDriver->GetMetadataItem(GDAL_DCAP_RASTER)) ||
+                    ((type & GDAL_OF_VECTOR) != 0 &&
+                     poDriver->GetMetadataItem(GDAL_DCAP_VECTOR)) ||
+                    ((type & GDAL_OF_MULTIDIM_RASTER) != 0 &&
+                     poDriver->GetMetadataItem(GDAL_DCAP_MULTIDIM_RASTER)))
+                {
+                    const char *pszExtensions =
+                        poDriver->GetMetadataItem(GDAL_DMD_EXTENSIONS);
+                    if (pszExtensions)
+                    {
+                        const CPLStringList aosExts(
+                            CSLTokenizeString2(pszExtensions, " ", 0));
+                        for (const char *pszExt : cpl::Iterate(aosExts))
+                            oExtensions.insert(CPLString(pszExt).tolower());
+                    }
+                }
+            }
+
+            std::string osDir = CPLGetDirname(currentValue.c_str());
+            auto psDir = VSIOpenDir(osDir.c_str(), 0, nullptr);
+            const std::string osSep = VSIGetDirectorySeparator(osDir.c_str());
+            if (currentValue.empty())
+                osDir.clear();
+            const std::string currentFilename =
+                CPLGetFilename(currentValue.c_str());
+            if (psDir)
+            {
+                while (const VSIDIREntry *psEntry = VSIGetNextDirEntry(psDir))
+                {
+                    if ((currentFilename.empty() ||
+                         STARTS_WITH(psEntry->pszName,
+                                     currentFilename.c_str())) &&
+                        strcmp(psEntry->pszName, ".") != 0 &&
+                        strcmp(psEntry->pszName, "..") != 0 &&
+                        !strstr(psEntry->pszName, ".aux.xml"))
+                    {
+                        if (cpl::contains(
+                                oExtensions,
+                                CPLString(CPLGetExtension(psEntry->pszName))
+                                    .tolower()) ||
+                            VSI_ISDIR(psEntry->nMode))
+                        {
+                            std::string osVal;
+                            if (osDir.empty())
+                                osVal = psEntry->pszName;
+                            else
+                                osVal = CPLFormFilename(
+                                    osDir.c_str(), psEntry->pszName, nullptr);
+                            if (VSI_ISDIR(psEntry->nMode))
+                                osVal += osSep;
+                            oRet.push_back(osVal);
+                        }
+                    }
+                }
+                VSICloseDir(psDir);
+            }
+            return oRet;
+        });
+
     return arg;
 }
 
@@ -1912,6 +2089,124 @@ GDALInConstructionAlgorithmArg &GDALAlgorithm::AddUpdateArg(bool *pValue)
         .SetDefault(false);
 }
 
+/************************************************************************/
+/*                          AddOptionsSuggestions()                     */
+/************************************************************************/
+
+static bool AddOptionsSuggestions(const char *pszXML, int datasetType,
+                                  const std::string &currentValue,
+                                  std::vector<std::string> &oRet)
+{
+    if (!pszXML)
+        return false;
+    CPLXMLTreeCloser poTree(CPLParseXMLString(pszXML));
+    if (!poTree)
+        return false;
+    const CPLXMLNode *psRoot =
+        CPLGetXMLNode(poTree.get(), "=CreationOptionList");
+    if (!psRoot)
+        psRoot = CPLGetXMLNode(poTree.get(), "=LayerCreationOptionList");
+    if (!psRoot)
+        psRoot = CPLGetXMLNode(poTree.get(), "=OpenOptionList");
+    if (!psRoot)
+        return false;
+
+    for (const CPLXMLNode *psChild = psRoot->psChild; psChild;
+         psChild = psChild->psNext)
+    {
+        const char *pszName = CPLGetXMLValue(psChild, "name", nullptr);
+        if (pszName && currentValue == pszName &&
+            EQUAL(psChild->pszValue, "Option"))
+        {
+            const char *pszType = CPLGetXMLValue(psChild, "type", "");
+            const char *pszMin = CPLGetXMLValue(psChild, "min", nullptr);
+            const char *pszMax = CPLGetXMLValue(psChild, "max", nullptr);
+            if (EQUAL(pszType, "string-select"))
+            {
+                for (const CPLXMLNode *psChild2 = psChild->psChild; psChild2;
+                     psChild2 = psChild2->psNext)
+                {
+                    if (EQUAL(psChild2->pszValue, "Value"))
+                    {
+                        oRet.push_back(CPLGetXMLValue(psChild2, "", ""));
+                    }
+                }
+            }
+            else if (EQUAL(pszType, "boolean"))
+            {
+                oRet.push_back("NO");
+                oRet.push_back("YES");
+            }
+            else if (EQUAL(pszType, "int"))
+            {
+                if (pszMin && pszMax && atoi(pszMax) - atoi(pszMin) > 0 &&
+                    atoi(pszMax) - atoi(pszMin) < 25)
+                {
+                    const int nMax = atoi(pszMax);
+                    for (int i = atoi(pszMin); i <= nMax; ++i)
+                        oRet.push_back(std::to_string(i));
+                }
+            }
+
+            if (oRet.empty())
+            {
+                if (pszMin && pszMax)
+                {
+                    oRet.push_back(std::string("##"));
+                    oRet.push_back(std::string("validity range: [")
+                                       .append(pszMin)
+                                       .append(",")
+                                       .append(pszMax)
+                                       .append("]"));
+                }
+                else if (pszMin)
+                {
+                    oRet.push_back(std::string("##"));
+                    oRet.push_back(
+                        std::string("validity range: >= ").append(pszMin));
+                }
+                else if (pszMax)
+                {
+                    oRet.push_back(std::string("##"));
+                    oRet.push_back(
+                        std::string("validity range: <= ").append(pszMax));
+                }
+                else if (const char *pszDescription =
+                             CPLGetXMLValue(psChild, "description", nullptr))
+                {
+                    oRet.push_back(std::string("##"));
+                    oRet.push_back(std::string("type: ")
+                                       .append(pszType)
+                                       .append(", description: ")
+                                       .append(pszDescription));
+                }
+            }
+
+            return true;
+        }
+    }
+
+    for (const CPLXMLNode *psChild = psRoot->psChild; psChild;
+         psChild = psChild->psNext)
+    {
+        const char *pszName = CPLGetXMLValue(psChild, "name", nullptr);
+        if (pszName && EQUAL(psChild->pszValue, "Option"))
+        {
+            const char *pszScope = CPLGetXMLValue(psChild, "scope", nullptr);
+            if (!pszScope ||
+                (EQUAL(pszScope, "raster") &&
+                 (datasetType & GDAL_OF_RASTER) != 0) ||
+                (EQUAL(pszScope, "vector") &&
+                 (datasetType & GDAL_OF_VECTOR) != 0))
+            {
+                oRet.push_back(std::string(pszName).append("="));
+            }
+        }
+    }
+
+    return false;
+}
+
 /************************************************************************/
 /*                 GDALAlgorithm::AddOpenOptionsArg()                   */
 /************************************************************************/
@@ -1919,10 +2214,99 @@ GDALInConstructionAlgorithmArg &GDALAlgorithm::AddUpdateArg(bool *pValue)
 GDALInConstructionAlgorithmArg &
 GDALAlgorithm::AddOpenOptionsArg(std::vector<std::string> *pValue)
 {
-    return AddArg("open-option", 0, _("Open options"), pValue)
-        .AddAlias("oo")
-        .SetMetaVar("KEY=VALUE")
-        .SetCategory(GAAC_ADVANCED);
+    auto &arg = AddArg(GDAL_ARG_NAME_OPEN_OPTION, 0, _("Open options"), pValue)
+                    .AddAlias("oo")
+                    .SetMetaVar("KEY=VALUE")
+                    .SetCategory(GAAC_ADVANCED);
+
+    arg.SetAutoCompleteFunction(
+        [this](const std::string &currentValue)
+        {
+            std::vector<std::string> oRet;
+
+            int datasetType =
+                GDAL_OF_RASTER | GDAL_OF_VECTOR | GDAL_OF_MULTIDIM_RASTER;
+            auto inputArg = GetArg(GDAL_ARG_NAME_INPUT);
+            if (inputArg && inputArg->GetType() == GAAT_DATASET)
+            {
+                auto &datasetValue = inputArg->Get<GDALArgDatasetValue>();
+                datasetType = datasetValue.GetType();
+            }
+
+            auto inputFormat = GetArg(GDAL_ARG_NAME_INPUT_FORMAT);
+            if (inputFormat && inputFormat->GetType() == GAAT_STRING_LIST &&
+                inputFormat->IsExplicitlySet())
+            {
+                const auto &aosAllowedDrivers =
+                    inputFormat->Get<std::vector<std::string>>();
+                if (aosAllowedDrivers.size() == 1)
+                {
+                    auto poDriver = GetGDALDriverManager()->GetDriverByName(
+                        aosAllowedDrivers[0].c_str());
+                    if (poDriver)
+                    {
+                        AddOptionsSuggestions(
+                            poDriver->GetMetadataItem(GDAL_DMD_OPENOPTIONLIST),
+                            datasetType, currentValue, oRet);
+                    }
+                    return oRet;
+                }
+            }
+
+            if (inputArg && inputArg->GetType() == GAAT_DATASET)
+            {
+                auto poDM = GetGDALDriverManager();
+                auto &datasetValue = inputArg->Get<GDALArgDatasetValue>();
+                const auto osDSName = datasetValue.GetName();
+                const std::string osExt = CPLGetExtension(osDSName.c_str());
+                if (!osExt.empty())
+                {
+                    std::set<std::string> oVisitedExtensions;
+                    for (int i = 0; i < poDM->GetDriverCount(); ++i)
+                    {
+                        auto poDriver = poDM->GetDriver(i);
+                        if (((datasetType & GDAL_OF_RASTER) != 0 &&
+                             poDriver->GetMetadataItem(GDAL_DCAP_RASTER)) ||
+                            ((datasetType & GDAL_OF_VECTOR) != 0 &&
+                             poDriver->GetMetadataItem(GDAL_DCAP_VECTOR)) ||
+                            ((datasetType & GDAL_OF_MULTIDIM_RASTER) != 0 &&
+                             poDriver->GetMetadataItem(
+                                 GDAL_DCAP_MULTIDIM_RASTER)))
+                        {
+                            const char *pszExtensions =
+                                poDriver->GetMetadataItem(GDAL_DMD_EXTENSIONS);
+                            if (pszExtensions)
+                            {
+                                const CPLStringList aosExts(
+                                    CSLTokenizeString2(pszExtensions, " ", 0));
+                                for (const char *pszExt : cpl::Iterate(aosExts))
+                                {
+                                    if (EQUAL(pszExt, osExt.c_str()) &&
+                                        !cpl::contains(oVisitedExtensions,
+                                                       pszExt))
+                                    {
+                                        oVisitedExtensions.insert(pszExt);
+                                        if (AddOptionsSuggestions(
+                                                poDriver->GetMetadataItem(
+                                                    GDAL_DMD_OPENOPTIONLIST),
+                                                datasetType, currentValue,
+                                                oRet))
+                                        {
+                                            return oRet;
+                                        }
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            return oRet;
+        });
+
+    return arg;
 }
 
 /************************************************************************/
@@ -1996,6 +2380,51 @@ bool GDALAlgorithm::ValidateFormat(const GDALAlgorithmArg &arg) const
     return true;
 }
 
+/************************************************************************/
+/*                    FormatAutoCompleteFunction()                      */
+/************************************************************************/
+
+static std::vector<std::string>
+FormatAutoCompleteFunction(const GDALAlgorithmArg &arg)
+{
+    std::vector<std::string> res;
+    auto poDM = GetGDALDriverManager();
+    for (int i = 0; i < poDM->GetDriverCount(); ++i)
+    {
+        auto poDriver = poDM->GetDriver(i);
+
+        const auto caps = arg.GetMetadataItem(GAAMDI_REQUIRED_CAPABILITIES);
+        if (caps)
+        {
+            bool ok = true;
+            for (const std::string &cap : *caps)
+            {
+                if (poDriver->GetMetadataItem(cap.c_str()))
+                {
+                }
+                else if (cap == GDAL_DCAP_CREATECOPY &&
+                         std::find(caps->begin(), caps->end(),
+                                   GDAL_DCAP_RASTER) != caps->end() &&
+                         poDriver->GetMetadataItem(GDAL_DCAP_RASTER) &&
+                         poDriver->GetMetadataItem(GDAL_DCAP_CREATE))
+                {
+                    // if it supports Create, it supports CreateCopy
+                }
+                else
+                {
+                    ok = false;
+                    break;
+                }
+            }
+            if (ok)
+            {
+                res.push_back(poDriver->GetDescription());
+            }
+        }
+    }
+    return res;
+}
+
 /************************************************************************/
 /*                 GDALAlgorithm::AddInputFormatsArg()                  */
 /************************************************************************/
@@ -2003,10 +2432,13 @@ bool GDALAlgorithm::ValidateFormat(const GDALAlgorithmArg &arg) const
 GDALInConstructionAlgorithmArg &
 GDALAlgorithm::AddInputFormatsArg(std::vector<std::string> *pValue)
 {
-    auto &arg = AddArg("input-format", 0, _("Input formats"), pValue)
-                    .AddAlias("if")
-                    .SetCategory(GAAC_ADVANCED);
+    auto &arg =
+        AddArg(GDAL_ARG_NAME_INPUT_FORMAT, 0, _("Input formats"), pValue)
+            .AddAlias("if")
+            .SetCategory(GAAC_ADVANCED);
     arg.AddValidationAction([this, &arg]() { return ValidateFormat(arg); });
+    arg.SetAutoCompleteFunction([&arg](const std::string &)
+                                { return FormatAutoCompleteFunction(arg); });
     return arg;
 }
 
@@ -2017,10 +2449,13 @@ GDALAlgorithm::AddInputFormatsArg(std::vector<std::string> *pValue)
 GDALInConstructionAlgorithmArg &
 GDALAlgorithm::AddOutputFormatArg(std::string *pValue)
 {
-    auto &arg = AddArg("output-format", 'f', _("Output format"), pValue)
-                    .AddAlias("of")
-                    .AddAlias("format");
+    auto &arg =
+        AddArg(GDAL_ARG_NAME_OUTPUT_FORMAT, 'f', _("Output format"), pValue)
+            .AddAlias("of")
+            .AddAlias("format");
     arg.AddValidationAction([this, &arg]() { return ValidateFormat(arg); });
+    arg.SetAutoCompleteFunction([&arg](const std::string &)
+                                { return FormatAutoCompleteFunction(arg); });
     return arg;
 }
 
@@ -2105,6 +2540,89 @@ GDALAlgorithm::AddCreationOptionsArg(std::vector<std::string> *pValue)
                     .AddAlias("co")
                     .SetMetaVar("<KEY>=<VALUE>");
     arg.AddValidationAction([this, &arg]() { return ValidateKeyValue(arg); });
+
+    arg.SetAutoCompleteFunction(
+        [this](const std::string &currentValue)
+        {
+            std::vector<std::string> oRet;
+
+            int datasetType =
+                GDAL_OF_RASTER | GDAL_OF_VECTOR | GDAL_OF_MULTIDIM_RASTER;
+            auto outputArg = GetArg(GDAL_ARG_NAME_OUTPUT);
+            if (outputArg && outputArg->GetType() == GAAT_DATASET)
+            {
+                auto &datasetValue = outputArg->Get<GDALArgDatasetValue>();
+                datasetType = datasetValue.GetType();
+            }
+
+            auto outputFormat = GetArg(GDAL_ARG_NAME_OUTPUT_FORMAT);
+            if (outputFormat && outputFormat->GetType() == GAAT_STRING &&
+                outputFormat->IsExplicitlySet())
+            {
+                auto poDriver = GetGDALDriverManager()->GetDriverByName(
+                    outputFormat->Get<std::string>().c_str());
+                if (poDriver)
+                {
+                    AddOptionsSuggestions(
+                        poDriver->GetMetadataItem(GDAL_DMD_CREATIONOPTIONLIST),
+                        datasetType, currentValue, oRet);
+                }
+                return oRet;
+            }
+
+            if (outputArg && outputArg->GetType() == GAAT_DATASET)
+            {
+                auto poDM = GetGDALDriverManager();
+                auto &datasetValue = outputArg->Get<GDALArgDatasetValue>();
+                const auto osDSName = datasetValue.GetName();
+                const std::string osExt = CPLGetExtension(osDSName.c_str());
+                if (!osExt.empty())
+                {
+                    std::set<std::string> oVisitedExtensions;
+                    for (int i = 0; i < poDM->GetDriverCount(); ++i)
+                    {
+                        auto poDriver = poDM->GetDriver(i);
+                        if (((datasetType & GDAL_OF_RASTER) != 0 &&
+                             poDriver->GetMetadataItem(GDAL_DCAP_RASTER)) ||
+                            ((datasetType & GDAL_OF_VECTOR) != 0 &&
+                             poDriver->GetMetadataItem(GDAL_DCAP_VECTOR)) ||
+                            ((datasetType & GDAL_OF_MULTIDIM_RASTER) != 0 &&
+                             poDriver->GetMetadataItem(
+                                 GDAL_DCAP_MULTIDIM_RASTER)))
+                        {
+                            const char *pszExtensions =
+                                poDriver->GetMetadataItem(GDAL_DMD_EXTENSIONS);
+                            if (pszExtensions)
+                            {
+                                const CPLStringList aosExts(
+                                    CSLTokenizeString2(pszExtensions, " ", 0));
+                                for (const char *pszExt : cpl::Iterate(aosExts))
+                                {
+                                    if (EQUAL(pszExt, osExt.c_str()) &&
+                                        !cpl::contains(oVisitedExtensions,
+                                                       pszExt))
+                                    {
+                                        oVisitedExtensions.insert(pszExt);
+                                        if (AddOptionsSuggestions(
+                                                poDriver->GetMetadataItem(
+                                                    GDAL_DMD_CREATIONOPTIONLIST),
+                                                datasetType, currentValue,
+                                                oRet))
+                                        {
+                                            return oRet;
+                                        }
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            return oRet;
+        });
+
     return arg;
 }
 
@@ -2120,6 +2638,75 @@ GDALAlgorithm::AddLayerCreationOptionsArg(std::vector<std::string> *pValue)
             .AddAlias("lco")
             .SetMetaVar("<KEY>=<VALUE>");
     arg.AddValidationAction([this, &arg]() { return ValidateKeyValue(arg); });
+
+    arg.SetAutoCompleteFunction(
+        [this](const std::string &currentValue)
+        {
+            std::vector<std::string> oRet;
+
+            auto outputFormat = GetArg(GDAL_ARG_NAME_OUTPUT_FORMAT);
+            if (outputFormat && outputFormat->GetType() == GAAT_STRING &&
+                outputFormat->IsExplicitlySet())
+            {
+                auto poDriver = GetGDALDriverManager()->GetDriverByName(
+                    outputFormat->Get<std::string>().c_str());
+                if (poDriver)
+                {
+                    AddOptionsSuggestions(poDriver->GetMetadataItem(
+                                              GDAL_DS_LAYER_CREATIONOPTIONLIST),
+                                          GDAL_OF_VECTOR, currentValue, oRet);
+                }
+                return oRet;
+            }
+
+            auto outputArg = GetArg(GDAL_ARG_NAME_OUTPUT);
+            if (outputArg && outputArg->GetType() == GAAT_DATASET)
+            {
+                auto poDM = GetGDALDriverManager();
+                auto &datasetValue = outputArg->Get<GDALArgDatasetValue>();
+                const auto osDSName = datasetValue.GetName();
+                const std::string osExt = CPLGetExtension(osDSName.c_str());
+                if (!osExt.empty())
+                {
+                    std::set<std::string> oVisitedExtensions;
+                    for (int i = 0; i < poDM->GetDriverCount(); ++i)
+                    {
+                        auto poDriver = poDM->GetDriver(i);
+                        if (poDriver->GetMetadataItem(GDAL_DCAP_VECTOR))
+                        {
+                            const char *pszExtensions =
+                                poDriver->GetMetadataItem(GDAL_DMD_EXTENSIONS);
+                            if (pszExtensions)
+                            {
+                                const CPLStringList aosExts(
+                                    CSLTokenizeString2(pszExtensions, " ", 0));
+                                for (const char *pszExt : cpl::Iterate(aosExts))
+                                {
+                                    if (EQUAL(pszExt, osExt.c_str()) &&
+                                        !cpl::contains(oVisitedExtensions,
+                                                       pszExt))
+                                    {
+                                        oVisitedExtensions.insert(pszExt);
+                                        if (AddOptionsSuggestions(
+                                                poDriver->GetMetadataItem(
+                                                    GDAL_DS_LAYER_CREATIONOPTIONLIST),
+                                                GDAL_OF_VECTOR, currentValue,
+                                                oRet))
+                                        {
+                                            return oRet;
+                                        }
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            return oRet;
+        });
+
     return arg;
 }
 
@@ -2796,6 +3383,150 @@ std::string GDALAlgorithm::GetUsageAsJSON() const
     return oDoc.SaveAsString();
 }
 
+/************************************************************************/
+/*                    GDALAlgorithm::GetAutoComplete()                  */
+/************************************************************************/
+
+std::vector<std::string>
+GDALAlgorithm::GetAutoComplete(std::vector<std::string> &args,
+                               bool showAllOptions)
+{
+    std::vector<std::string> ret;
+
+    std::string option;
+    std::string value;
+    ExtractLastOptionAndValue(args, option, value);
+
+    if (option.empty() && !args.empty() && !args.back().empty() &&
+        args.back()[0] == '-')
+    {
+        // List available options
+        for (const auto &arg : GetArgs())
+        {
+            if (arg->IsHiddenForCLI() ||
+                (!showAllOptions &&
+                 (arg->GetName() == "help" || arg->GetName() == "drivers" ||
+                  arg->GetName() == "config" || arg->GetName() == "version" ||
+                  arg->GetName() == "json-usage")))
+            {
+                continue;
+            }
+            if (!arg->GetShortName().empty())
+            {
+                ret.push_back(std::string("-").append(arg->GetShortName()));
+            }
+            for (const std::string &alias : arg->GetAliases())
+            {
+                ret.push_back(std::string("--").append(alias));
+            }
+            if (!arg->GetName().empty())
+            {
+                ret.push_back(std::string("--").append(arg->GetName()));
+            }
+        }
+    }
+    else if (!option.empty())
+    {
+        // List possible choices for current option
+        auto arg = GetArg(option);
+        if (arg && arg->GetType() != GAAT_BOOLEAN)
+        {
+            ret = arg->GetChoices();
+            if (ret.empty())
+            {
+                {
+                    CPLErrorStateBackuper oErrorQuieter(CPLQuietErrorHandler);
+                    SetParseForAutoCompletion();
+                    CPL_IGNORE_RET_VAL(ParseCommandLineArguments(args));
+                }
+                ret = arg->GetAutoCompleteChoices(value);
+            }
+            if (ret.empty())
+            {
+                ret.push_back("**");
+                ret.push_back(
+                    std::string("description: ").append(arg->GetDescription()));
+            }
+        }
+    }
+    else if (!args.empty() && STARTS_WITH(args.back().c_str(), "/vsi"))
+    {
+        auto arg = GetArg(GDAL_ARG_NAME_INPUT);
+        if (arg)
+        {
+            ret = arg->GetAutoCompleteChoices(args.back());
+        }
+    }
+    else
+    {
+        // List possible sub-algorithms
+        ret = GetSubAlgorithmNames();
+    }
+
+    return ret;
+}
+
+/************************************************************************/
+/*             GDALAlgorithm::ExtractLastOptionAndValue()               */
+/************************************************************************/
+
+void GDALAlgorithm::ExtractLastOptionAndValue(std::vector<std::string> &args,
+                                              std::string &option,
+                                              std::string &value) const
+{
+    if (!args.empty() && !args.back().empty() && args.back()[0] == '-')
+    {
+        const auto nPosEqual = args.back().find('=');
+        if (nPosEqual == std::string::npos)
+        {
+            // Deal with "gdal ... --option"
+            if (GetArg(args.back()))
+            {
+                option = args.back();
+                args.pop_back();
+            }
+        }
+        else
+        {
+            // Deal with "gdal ... --option=<value>"
+            if (GetArg(args.back().substr(0, nPosEqual)))
+            {
+                option = args.back().substr(0, nPosEqual);
+                value = args.back().substr(nPosEqual + 1);
+                args.pop_back();
+            }
+        }
+    }
+    else if (args.size() >= 2 && !args[args.size() - 2].empty() &&
+             args[args.size() - 2][0] == '-')
+    {
+        // Deal with "gdal ... --option <value>"
+        auto arg = GetArg(args[args.size() - 2]);
+        if (arg && arg->GetType() != GAAT_BOOLEAN)
+        {
+            option = args[args.size() - 2];
+            value = args.back();
+            args.pop_back();
+        }
+    }
+
+    const auto IsKeyValueOption = [](const std::string &osStr)
+    {
+        return osStr == "--co" || osStr == "--creation-option" ||
+               osStr == "--lco" || osStr == "--layer-creation-option" ||
+               osStr == "--oo" || osStr == "--open-option";
+    };
+
+    if (IsKeyValueOption(option))
+    {
+        const auto nPosEqual = value.find('=');
+        if (nPosEqual != std::string::npos)
+        {
+            value.resize(nPosEqual);
+        }
+    }
+}
+
 /************************************************************************/
 /*                        GDALAlgorithmRelease()                        */
 /************************************************************************/
diff --git a/gcore/gdalalgorithm.h b/gcore/gdalalgorithm.h
index cb7c50e782fb..25d0c8815f0f 100644
--- a/gcore/gdalalgorithm.h
+++ b/gcore/gdalalgorithm.h
@@ -1109,6 +1109,17 @@ class CPL_DLL GDALAlgorithmArg /* non-final */
         return m_decl.GetChoices();
     }
 
+    /** Return auto completion choices, if a auto completion function has been
+     * registered.
+     */
+    inline std::vector<std::string>
+    GetAutoCompleteChoices(const std::string &currentValue) const
+    {
+        if (m_autoCompleteFunction)
+            return m_autoCompleteFunction(currentValue);
+        return {};
+    }
+
     /** Return whether the argument value has been explicitly set with Set() */
     inline bool IsExplicitlySet() const
     {
@@ -1367,6 +1378,9 @@ class CPL_DLL GDALAlgorithmArg /* non-final */
     std::vector<std::function<void()>> m_actions{};
     /** Validation actions */
     std::vector<std::function<bool()>> m_validationActions{};
+    /** Autocompletion function */
+    std::function<std::vector<std::string>(const std::string &)>
+        m_autoCompleteFunction{};
 
   private:
     bool m_skipIfAlreadySet = false;
@@ -1583,6 +1597,16 @@ class CPL_DLL GDALInConstructionAlgorithmArg final : public GDALAlgorithmArg
         return *this;
     }
 
+    /** Register a function that will return a list of valid choices for
+     * the value of the argument. This is typically used for autocompletion.
+     */
+    GDALInConstructionAlgorithmArg &SetAutoCompleteFunction(
+        std::function<std::vector<std::string>(const std::string &)> f)
+    {
+        m_autoCompleteFunction = f;
+        return *this;
+    }
+
     /** Register an action to validate that the argument value is a valid
      * CRS definition.
      * @param noneAllowed Set to true to mean that "null" or "none" are allowed
@@ -1773,19 +1797,15 @@ class CPL_DLL GDALAlgorithmRegistry
         return m_args;
     }
 
-    /** Return an argument from its (long) name */
+    /** Return an argument from its long name, short name or an alias */
     GDALAlgorithmArg *GetArg(const std::string &osName)
     {
-        auto oIter = m_mapLongNameToArg.find(osName);
-        return oIter != m_mapLongNameToArg.end() ? oIter->second : nullptr;
+        return const_cast<GDALAlgorithmArg *>(
+            const_cast<const GDALAlgorithm *>(this)->GetArg(osName));
     }
 
-    /** Return an argument from its (long) name */
-    const GDALAlgorithmArg *GetArg(const std::string &osName) const
-    {
-        auto oIter = m_mapLongNameToArg.find(osName);
-        return oIter != m_mapLongNameToArg.end() ? oIter->second : nullptr;
-    }
+    /** Return an argument from its long name, short name or an alias */
+    const GDALAlgorithmArg *GetArg(const std::string &osName) const;
 
     /** Set the calling path to this algorithm.
      *
@@ -1797,6 +1817,15 @@ class CPL_DLL GDALAlgorithmRegistry
         m_callPath = path;
     }
 
+    /** Set hint before calling ParseCommandLineArguments() that it must
+     * try to be be graceful when possible, e.g. accepting
+     * "gdal raster convert in.tif out.tif --co"
+     */
+    void SetParseForAutoCompletion()
+    {
+        m_parseForAutoCompletion = true;
+    }
+
     /** Parse a command line argument, which does not include the algorithm
      * name, to set the value of corresponding arguments.
      */
@@ -1901,6 +1930,10 @@ class CPL_DLL GDALAlgorithmRegistry
         return false;
     }
 
+    /** Return auto completion suggestions */
+    virtual std::vector<std::string>
+    GetAutoComplete(std::vector<std::string> &args, bool showAllOptions);
+
   protected:
     friend class GDALInConstructionAlgorithmArg;
 
@@ -2107,12 +2140,16 @@ class CPL_DLL GDALAlgorithmRegistry
     bool m_helpRequested = false;
     bool m_JSONUsageRequested = false;
     bool m_dummyBoolean = false;  // Used for --version
+    bool m_parseForAutoCompletion = false;
+    std::vector<std::string> m_dummyConfigOptions{};
     std::vector<std::unique_ptr<GDALAlgorithmArg>> m_args{};
     std::map<std::string, GDALAlgorithmArg *> m_mapLongNameToArg{};
     std::map<std::string, GDALAlgorithmArg *> m_mapShortNameToArg{};
     std::vector<GDALAlgorithmArg *> m_positionalArgs{};
     GDALAlgorithmRegistry m_subAlgRegistry{};
     std::unique_ptr<GDALAlgorithm> m_shortCutAlg{};
+    std::function<std::vector<std::string>(const std::vector<std::string> &)>
+        m_autoCompleteFunction{};
 
     GDALInConstructionAlgorithmArg &
     AddArg(std::unique_ptr<GDALInConstructionAlgorithmArg> arg);
@@ -2129,6 +2166,13 @@ class CPL_DLL GDALAlgorithmRegistry
 
     virtual bool RunImpl(GDALProgressFunc pfnProgress, void *pProgressData) = 0;
 
+    /** Extract the last option and its potential value from the provided
+     * argument list, and remove them from the list.
+     */
+    void ExtractLastOptionAndValue(std::vector<std::string> &args,
+                                   std::string &option,
+                                   std::string &value) const;
+
     GDALAlgorithm(const GDALAlgorithm &) = delete;
     GDALAlgorithm &operator=(const GDALAlgorithm &) = delete;
 };
diff --git a/scripts/completionFinder.py b/scripts/completionFinder.py
index cecf0f04f32e..bde75eb1a76c 100644
--- a/scripts/completionFinder.py
+++ b/scripts/completionFinder.py
@@ -183,7 +183,9 @@ def getCompletionScript(name, optList):
             output.append("  esac\n")
     else:
         # ogr type
-        formatParsingCmd = "$tool --formats | tail -n +2 | grep -o -E '\"[^\"]+\"' | sed 's/\ /__/'"  # noqa: W605
+        formatParsingCmd = (
+            "$tool --formats | tail -n +2 | grep -o -E '\"[^\"]+\"' | sed 's/\\ /__/'"
+        )
         if "-f" in optList:
             # replace ogrtindex by ogr2ogr to check --formats
             output.append("  tool=${COMP_WORDS[0]/ogrtindex/ogr2ogr}\n")
@@ -275,6 +277,39 @@ def main(argv):
 # Checks that bash-completion is recent enough
 function_exists _get_comp_words_by_ref || return 0
 
+_gdal()
+{
+  local cur prev
+  COMPREPLY=()
+  _get_comp_words_by_ref cur prev
+  choices=$(gdal completion ${COMP_LINE})
+  if [[ "$cur" == "=" ]]; then
+    mapfile -t COMPREPLY < <(compgen -W "$choices" --)
+  elif [[ "$cur" == ":" ]]; then
+    mapfile -t COMPREPLY < <(compgen -W "$choices" --)
+  elif [[ "$cur" == "!" ]]; then
+    mapfile -t COMPREPLY < <(compgen -W "$choices" -P "! " --)
+  else
+    mapfile -t COMPREPLY < <(compgen -W "$choices" -- "$cur")
+  fi
+  for element in "${COMPREPLY[@]}"; do
+    if [[ $element == */ ]]; then
+      # Do not add a space if one of the suggestion ends with slash
+      compopt -o nospace
+      break
+    elif [[ $element == *= ]]; then
+      # Do not add a space if one of the suggestion ends with equal
+      compopt -o nospace
+      break
+    elif [[ $element == *: ]]; then
+      # Do not add a space if one of the suggestion ends with colon
+      compopt -o nospace
+      break
+    fi
+  done
+}
+complete -o default -F _gdal gdal
+
 """
     )
 
diff --git a/scripts/gdal-bash-completion.sh b/scripts/gdal-bash-completion.sh
index 3a39501d3f3f..34e40e9cf5f0 100644
--- a/scripts/gdal-bash-completion.sh
+++ b/scripts/gdal-bash-completion.sh
@@ -9,6 +9,39 @@ function_exists() {
 # Checks that bash-completion is recent enough
 function_exists _get_comp_words_by_ref || return 0
 
+_gdal()
+{
+  local cur prev
+  COMPREPLY=()
+  _get_comp_words_by_ref cur prev
+  choices=$(gdal completion ${COMP_LINE})
+  if [[ "$cur" == "=" ]]; then
+    mapfile -t COMPREPLY < <(compgen -W "$choices" --)
+  elif [[ "$cur" == ":" ]]; then
+    mapfile -t COMPREPLY < <(compgen -W "$choices" --)
+  elif [[ "$cur" == "!" ]]; then
+    mapfile -t COMPREPLY < <(compgen -W "$choices" -P "! " --)
+  else
+    mapfile -t COMPREPLY < <(compgen -W "$choices" -- "$cur")
+  fi
+  for element in "${COMPREPLY[@]}"; do
+    if [[ $element == */ ]]; then
+      # Do not add a space if one of the suggestion ends with slash
+      compopt -o nospace
+      break
+    elif [[ $element == *= ]]; then
+      # Do not add a space if one of the suggestion ends with equal
+      compopt -o nospace
+      break
+    elif [[ $element == *: ]]; then
+      # Do not add a space if one of the suggestion ends with colon
+      compopt -o nospace
+      break
+    fi
+  done
+}
+complete -o default -F _gdal gdal
+
 _gdal2tiles.py()
 {
   local cur prev
@@ -253,669 +286,3 @@ _gdalenhance()
   return 0
 }
 complete -o default -F _gdalenhance gdalenhance
-_gdal_fillnodata.py()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --help-general -q -md -si -o -mask -interp -b -of -co --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    -of)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _gdal_fillnodata.py gdal_fillnodata.py
-_gdal_grid()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --long-usage --help-general --quiet -of -ot -txe -tye -outsize -tr -co -zfield -z_increase -z_multiply -where -l -sql -spat -clipsrc -clipsrcsql -clipsrclayer -clipsrcwhere -a_srs -a -oo --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    -ot)
-      key_list="Byte Int16 UInt16 UInt32 Int32 Float32 Float64 CInt16 CInt32 CFloat32 CFloat64"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    -of)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _gdal_grid gdal_grid
-_gdalinfo()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --long-usage --help-general -json -mm -stats -approx_stats -hist -nogcp -nomd -norat -noct -nofl -nonodata -nomask -checksum -listmdd -proj4 -wkt_format -sd -oo -if -mdd --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _gdalinfo gdalinfo
-_gdallocationinfo()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --long-usage --help-general -xml -lifonly -valonly -E -field_sep -ignore_extra_input -b -overview -r -l_srs -geoloc -wgs84 -oo --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _gdallocationinfo gdallocationinfo
-_gdalmanage()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --long-usage --help-general --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _gdalmanage gdalmanage
-_gdal_merge.py()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --help-general -o -of -co -ps -tap -separate -q -v -pct -ul_lr -init -n -a_nodata -ot -createonly --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    -ot)
-      key_list="Byte Int16 UInt16 UInt32 Int32 Float32 Float64 CInt16 CInt32 CFloat32 CFloat64"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    -of)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _gdal_merge.py gdal_merge.py
-_gdalmove.py()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --help-general -s_srs -et --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _gdalmove.py gdalmove.py
-_gdal_polygonize.py()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --help-general -q -8 -o -mask -nomask -b -of -lco -overwrite --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    -of)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _gdal_polygonize.py gdal_polygonize.py
-_gdal_proximity.py()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --help-general -srcband -dstband -of -co -ot -values -distunits -maxdist -nodata -use_input_nodata -fixed-buf-val -q --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    -ot)
-      key_list="Byte Int16 UInt16 UInt32 Int32 Float32 Float64 CInt16 CInt32 CFloat32 CFloat64"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    -of)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _gdal_proximity.py gdal_proximity.py
-_gdal_rasterize()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --long-usage --help-general -b -i -at -burn -a -3d -add -l -sql -where -dialect -a_nodata -init -a_srs -to -te -tr -ts -tap -optim -co -ot -of --quiet -oo --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    -ot)
-      key_list="Byte Int16 UInt16 UInt32 Int32 Float32 Float64 CInt16 CInt32 CFloat32 CFloat64"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    -of)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _gdal_rasterize gdal_rasterize
-_gdal_retile.py()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --help-general -v -q -co -of -ps -overlap -ot -tileIndex -tileIndexField -csv -csvDelim -s_srs -pyramidOnly -r -useDirForEachRow -resume --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    -ot)
-      key_list="Byte Int16 UInt16 UInt32 Int32 Float32 Float64 CInt16 CInt32 CFloat32 CFloat64"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    -of)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _gdal_retile.py gdal_retile.py
-_gdal_sieve.py()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --help-general -q -st -4 -8 -o -nomask -mask -of --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    -of)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _gdal_sieve.py gdal_sieve.py
-_gdalsrsinfo()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help-general --help -h --single-line -V -e -o --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _gdalsrsinfo gdalsrsinfo
-_gdaltindex()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --long-usage --help-general -overwrite -recursive -filename_filter -min_pixel_size -max_pixel_size -of -tileindex -write_absolute_path -skip_different_projection -t_srs -src_srs_name -src_srs_format -lyr_name -lco -gti_filename -tr -te -ot -bandcount -nodata -colorinterp -mask -mo -fetch_md --quiet --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    -ot)
-      key_list="Byte Int16 UInt16 UInt32 Int32 Float32 Float64 CInt16 CInt32 CFloat32 CFloat64"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    -of)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _gdaltindex gdaltindex
-_gdaltransform()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --help-general -i -s_srs -t_srs -to -s_coord_epoch -t_coord_epoch -ct -order -tps -rpc -geoloc -gcp -output_xy -E -field_sep -ignore_extra_input --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _gdaltransform gdaltransform
-_gdal_translate()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --long-usage --help-general -ot -if -of --quiet -b -mask -expand -strict -not_strict -outsize -tr -ovr -sds -r -scale -scale_X -unscale -exponent -exponent_X -srcwin -projwin -projwin_srs -epo -eco -a_srs -a_coord_epoch -a_ullr -a_nodata -a_gt -a_scale -a_offset -nogcp -gcp -colorinterp -colorinterp_X -stats -approx_stats -norat -noxmp -co -mo -dmo -oo --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    -ot)
-      key_list="Byte Int16 UInt16 UInt32 Int32 Float32 Float64 CInt16 CInt32 CFloat32 CFloat64"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    -of)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _gdal_translate gdal_translate
-_gdalwarp()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --long-usage --help-general --quiet -overwrite -of -co -s_srs -t_srs -srcalpha -nosrcalpha -dstalpha -tr -ts -te -te_srs -r -ot -wo -multi -s_coord_epoch -t_coord_epoch -ct -tps -rpc -geoloc -order -refine_gcps -to -et -wm -srcnodata -dstnodata -tap -wt -cutline -cutline_srs -cwhere -cl -csql -cblend -crop_to_cutline -nomd -cvmd -setci -oo -doo -ovr -vshift -novshiftgrid -if -srcband -dstband --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    -ot)
-      key_list="Byte Int16 UInt16 UInt32 Int32 Float32 Float64 CInt16 CInt32 CFloat32 CFloat64"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    -of)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _gdalwarp gdalwarp
-_gdal_viewshed()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --long-usage --help-general -of -ox -oy -oz -vv -iv -ov -co -a_nodata -tz -md -j -cc -b -om -os --quiet --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    -of)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _gdal_viewshed gdal_viewshed
-_gdal_create()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --long-usage --help-general -ot -of -outsize -bands -burn -a_srs -a_ullr -a_nodata -mo -co --quiet -if --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    -ot)
-      key_list="Byte Int16 UInt16 UInt32 Int32 Float32 Float64 CInt16 CInt32 CFloat32 CFloat64"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    -of)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _gdal_create gdal_create
-_sozip()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --long-usage --help-general --recurse-paths --grow --overwrite --list --validate --optimize-from --quiet --verbose --junk-paths --enable-sozip --sozip-chunk-size --sozip-min-file-size --content-type --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _sozip sozip
-_gdal_footprint()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --long-usage --help-general -b -combine_bands -ovr -srcnodata -t_cs -t_srs -split_polys -convex_hull -densify -simplify -min_ring_area -max_points --quiet -oo -of -location_field_name -no_location -write_absolute_path -lco -dsco -lyr_name -overwrite --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]}
-  case "$prev" in
-    -of)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-    --format)
-      key_list="$( $tool --formats | tail -n +2 | cut -f 3 -d ' ')"
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _gdal_footprint gdal_footprint
-_ogr2ogr()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --long-usage --help-general -of -dsco -lco -append -upsert -overwrite -update -sql -dialect -spat -where -select -nln -nlt -s_srs -a_srs -t_srs -addfields -relaxedFieldNameMatch -fieldTypeToString -mapFieldType -fieldmap -splitlistfields -maxsubfields -emptyStrAsNull -forceNullable -unsetFieldWidth -unsetDefault -resolveDomains -dateTimeTo -)<HH> -)<HH>:<MM> -noNativeData -dim -s_coord_epoch -a_coord_epoch -t_coord_epoch -ct -spat_srs -geomfield -segmentize -simplify -makevalid -skipinvalid -wrapdateline -datelineoffset -clipsrc -clipsrcsql -clipsrclayer -clipsrcwhere -clipdst -clipdstsql -clipdstlayer -clipdstwhere -explodecollections -zfield -gcp -tps -order -xyRes -zRes -mRes -unsetCoordPrecision --quiet -progress -if -oo -doo -fid -preserve_fid -unsetFid -skipfailures -gt -limit -ds_transaction -mo -nomd --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _ogr2ogr ogr2ogr
-_ogrinfo()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --long-usage --help-general -json -ro -update --quiet -fid -spat -geomfield -where -sql -rl -dialect -al -summary -features -limit -fields -geom -oo -nomd -listmdd -mdd -nocount -noextent -extent3D -nogeomtype -wkt_format -fielddomain -if --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _ogrinfo ogrinfo
-_ogrlineref()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --long-usage --help-general --quiet -progress -of -dsco -lco -create -l -ln -lf -p -pn -pm -pf -r -rn -o -on -s -get_pos -x -y -get_coord -m -get_subline -mb -me --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _ogrlineref ogrlineref
-_ogrtindex()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --long-usage --help-general -lnum -lname -of -tileindex -write_absolute_path -skip_different_projection -t_srs -src_srs_name -src_srs_format -accept_different_schemas --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _ogrtindex ogrtindex
-_ogrmerge.py()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --help-general -f -single -nln -update -append -src_geom_type -dsco -lco -s_srs -t_srs -a_srs -progress -skipfailures -field_strategy -src_layer_field_name -src_layer_field_content --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]/ogrtindex/ogr2ogr}
-  case "$prev" in
-    -f)
-      key_list="$( $tool --formats | tail -n +2 | grep -o -E '"[^"]+"' | sed 's/\ /__/')"
-      for iter in $key_list; do
-        if [[ $iter =~ ^$cur ]]; then
-          COMPREPLY+=( "${iter//__/ }" )
-        fi
-      done
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _ogrmerge.py ogrmerge.py
-_ogr_layer_algebra.py()
-{
-  local cur prev
-  COMPREPLY=()
-  _get_comp_words_by_ref cur prev
-  case "$cur" in
-    -*)
-      key_list="--help --help-general -input_lyr -method_lyr -output_lyr -overwrite -opt -f -dsco -lco -input_fields -method_fields -nlt -a_srs --version --build --license --formats --format --optfile --config --debug --pause --locale "
-      mapfile -t COMPREPLY < <(compgen -W "$key_list" -- "$cur")
-      return 0
-      ;;
-  esac
-  tool=${COMP_WORDS[0]/ogrtindex/ogr2ogr}
-  case "$prev" in
-    -f)
-      key_list="$( $tool --formats | tail -n +2 | grep -o -E '"[^"]+"' | sed 's/\ /__/')"
-      for iter in $key_list; do
-        if [[ $iter =~ ^$cur ]]; then
-          COMPREPLY+=( "${iter//__/ }" )
-        fi
-      done
-      ;;
-  esac
-  return 0
-}
-complete -o default -F _ogr_layer_algebra.py ogr_layer_algebra.py
diff --git a/scripts/setdevenv.sh b/scripts/setdevenv.sh
index eeecd1fdc757..d6968cc13b00 100755
--- a/scripts/setdevenv.sh
+++ b/scripts/setdevenv.sh
@@ -67,3 +67,8 @@ if [[ ! "${PYTHONPATH:-}" =~ $GDAL_PYTHONPATH ]]; then
     echo "Setting PYTHONPATH=$PYTHONPATH"
 fi
 unset GDAL_PYTHONPATH
+
+if [[ $BASH_VERSION ]]; then
+  echo "Sourcing ${GDAL_ROOT}/scripts/gdal-bash-completion.sh"
+  source "${GDAL_ROOT}/scripts/gdal-bash-completion.sh"
+fi

From 1c4942602b6edf06709a7229993772b5b8643a1c Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Fri, 3 Jan 2025 04:37:37 +0100
Subject: [PATCH 18/40] gcore: use GDALCopyWords64() instead of GDALCopyWords()
 for microscopic perf improvement

---
 gcore/gdalmultidim.cpp                       | 40 ++++++------
 gcore/gdalmultidim_gltorthorectification.cpp | 29 +++++----
 gcore/gdalnodatamaskband.cpp                 |  2 +-
 gcore/gdalrasterband.cpp                     | 12 ++--
 gcore/overview.cpp                           | 10 +--
 gcore/rasterio.cpp                           | 68 ++++++++++----------
 gcore/rawdataset.cpp                         | 46 ++++++-------
 7 files changed, 106 insertions(+), 101 deletions(-)

diff --git a/gcore/gdalmultidim.cpp b/gcore/gdalmultidim.cpp
index b26384a35b91..35ede4338684 100644
--- a/gcore/gdalmultidim.cpp
+++ b/gcore/gdalmultidim.cpp
@@ -66,10 +66,10 @@ class GDALMDArrayUnscaled final : public GDALPamMDArray
         m_abyRawNoData.resize(m_dt.GetSize());
         const auto eNonComplexDT =
             GDALGetNonComplexDataType(m_dt.GetNumericDataType());
-        GDALCopyWords(&dfOverriddenDstNodata, GDT_Float64, 0,
-                      m_abyRawNoData.data(), eNonComplexDT,
-                      GDALGetDataTypeSizeBytes(eNonComplexDT),
-                      GDALDataTypeIsComplex(m_dt.GetNumericDataType()) ? 2 : 1);
+        GDALCopyWords64(
+            &dfOverriddenDstNodata, GDT_Float64, 0, m_abyRawNoData.data(),
+            eNonComplexDT, GDALGetDataTypeSizeBytes(eNonComplexDT),
+            GDALDataTypeIsComplex(m_dt.GetNumericDataType()) ? 2 : 1);
     }
 
     bool IRead(const GUInt64 *arrayStartIdx, const size_t *count,
@@ -1623,8 +1623,8 @@ bool GDALExtendedDataType::CopyValue(const void *pSrc,
     if (srcType.GetClass() == GEDTC_NUMERIC &&
         dstType.GetClass() == GEDTC_NUMERIC)
     {
-        GDALCopyWords(pSrc, srcType.GetNumericDataType(), 0, pDst,
-                      dstType.GetNumericDataType(), 0, 1);
+        GDALCopyWords64(pSrc, srcType.GetNumericDataType(), 0, pDst,
+                        dstType.GetNumericDataType(), 0, 1);
         return true;
     }
     if (srcType.GetClass() == GEDTC_STRING &&
@@ -1733,8 +1733,8 @@ bool GDALExtendedDataType::CopyValue(const void *pSrc,
         {
             // FIXME GDT_UInt64
             const double dfVal = srcStrPtr == nullptr ? 0 : CPLAtof(srcStrPtr);
-            GDALCopyWords(&dfVal, GDT_Float64, 0, pDst,
-                          dstType.GetNumericDataType(), 0, 1);
+            GDALCopyWords64(&dfVal, GDT_Float64, 0, pDst,
+                            dstType.GetNumericDataType(), 0, 1);
         }
         return true;
     }
@@ -2621,8 +2621,8 @@ double GDALMDArray::GetNoDataValueAsDouble(bool *pbHasNoData) const
     const bool ok = pNoData != nullptr && eDT.GetClass() == GEDTC_NUMERIC;
     if (ok)
     {
-        GDALCopyWords(pNoData, eDT.GetNumericDataType(), 0, &dfNoData,
-                      GDT_Float64, 0, 1);
+        GDALCopyWords64(pNoData, eDT.GetNumericDataType(), 0, &dfNoData,
+                        GDT_Float64, 0, 1);
     }
     if (pbHasNoData)
         *pbHasNoData = ok;
@@ -2652,8 +2652,8 @@ int64_t GDALMDArray::GetNoDataValueAsInt64(bool *pbHasNoData) const
     const bool ok = pNoData != nullptr && eDT.GetClass() == GEDTC_NUMERIC;
     if (ok)
     {
-        GDALCopyWords(pNoData, eDT.GetNumericDataType(), 0, &nNoData, GDT_Int64,
-                      0, 1);
+        GDALCopyWords64(pNoData, eDT.GetNumericDataType(), 0, &nNoData,
+                        GDT_Int64, 0, 1);
     }
     if (pbHasNoData)
         *pbHasNoData = ok;
@@ -2683,8 +2683,8 @@ uint64_t GDALMDArray::GetNoDataValueAsUInt64(bool *pbHasNoData) const
     const bool ok = pNoData != nullptr && eDT.GetClass() == GEDTC_NUMERIC;
     if (ok)
     {
-        GDALCopyWords(pNoData, eDT.GetNumericDataType(), 0, &nNoData,
-                      GDT_UInt64, 0, 1);
+        GDALCopyWords64(pNoData, eDT.GetNumericDataType(), 0, &nNoData,
+                        GDT_UInt64, 0, 1);
     }
     if (pbHasNoData)
         *pbHasNoData = ok;
@@ -6387,8 +6387,8 @@ bool GDALMDArrayUnscaled::IWrite(const GUInt64 *arrayStartIdx,
     double dfNoData = 0;
     if (m_bHasNoData)
     {
-        GDALCopyWords(m_abyRawNoData.data(), m_dt.GetNumericDataType(), 0,
-                      &dfNoData, GDT_Float64, 0, 1);
+        GDALCopyWords64(m_abyRawNoData.data(), m_dt.GetNumericDataType(), 0,
+                        &dfNoData, GDT_Float64, 0, 1);
     }
 
     double adfSrcNoData[2] = {0, 0};
@@ -6552,10 +6552,10 @@ bool GDALMDArrayUnscaled::IWrite(const GUInt64 *arrayStartIdx,
         // Remaining elements
         for (size_t i = 1; i < nElts; ++i)
         {
-            GDALCopyWords(static_cast<GByte *>(pTempBuffer) + i * nDTSize,
-                          eNumericDT, 0,
-                          static_cast<GByte *>(pTempBuffer) + i * nParentDTSize,
-                          eParentNumericDT, 0, 1);
+            GDALCopyWords64(
+                static_cast<GByte *>(pTempBuffer) + i * nDTSize, eNumericDT, 0,
+                static_cast<GByte *>(pTempBuffer) + i * nParentDTSize,
+                eParentNumericDT, 0, 1);
         }
     }
 
diff --git a/gcore/gdalmultidim_gltorthorectification.cpp b/gcore/gdalmultidim_gltorthorectification.cpp
index e1183b5bb2fe..5e10c0a50c79 100644
--- a/gcore/gdalmultidim_gltorthorectification.cpp
+++ b/gcore/gdalmultidim_gltorthorectification.cpp
@@ -223,8 +223,8 @@ bool GLTOrthoRectifiedArray::IRead(const GUInt64 *arrayStartIdx,
     auto pRawNoDataValue = GetRawNoDataValue();
     std::vector<GByte> abyNoData(16);
     if (pRawNoDataValue)
-        GDALCopyWords(pRawNoDataValue, GetDataType().GetNumericDataType(), 0,
-                      abyNoData.data(), eBufferDT, 0, 1);
+        GDALCopyWords64(pRawNoDataValue, GetDataType().GetNumericDataType(), 0,
+                        abyNoData.data(), eBufferDT, 0, 1);
 
     const auto nBufferDTSize = bufferDataType.GetSize();
     const int nCopyWordsDstStride =
@@ -246,8 +246,9 @@ bool GLTOrthoRectifiedArray::IRead(const GUInt64 *arrayStartIdx,
                     static_cast<GByte *>(pDstBuffer) +
                     (iY * bufferStride[0] + iX * bufferStride[1]) *
                         static_cast<int>(nBufferDTSize);
-                GDALCopyWords(abyNoData.data(), eBufferDT, 0, pabyDstBuffer,
-                              eBufferDT, nCopyWordsDstStride, nCopyWordsCount);
+                GDALCopyWords64(abyNoData.data(), eBufferDT, 0, pabyDstBuffer,
+                                eBufferDT, nCopyWordsDstStride,
+                                nCopyWordsCount);
             }
         }
     };
@@ -401,9 +402,10 @@ bool GLTOrthoRectifiedArray::IRead(const GUInt64 *arrayStartIdx,
                 const GByte *pabySrcBuffer =
                     parentValues.data() +
                     (iSrcY * nXCount + iSrcX) * nBandCount * nBufferDTSize;
-                GDALCopyWords(pabySrcBuffer, eBufferDT,
-                              static_cast<int>(nBufferDTSize), pabyDstBuffer,
-                              eBufferDT, nCopyWordsDstStride, nCopyWordsCount);
+                GDALCopyWords64(pabySrcBuffer, eBufferDT,
+                                static_cast<int>(nBufferDTSize), pabyDstBuffer,
+                                eBufferDT, nCopyWordsDstStride,
+                                nCopyWordsCount);
                 if (bSomeBandInvalids)
                 {
                     for (size_t i = 0; i < count[2]; ++i)
@@ -412,18 +414,19 @@ bool GLTOrthoRectifiedArray::IRead(const GUInt64 *arrayStartIdx,
                             arrayStartIdx[2] + i * arrayStep[2]);
                         if (!m_abyBandValidity[iBand])
                         {
-                            GDALCopyWords(abyNoData.data(), eBufferDT, 0,
-                                          pabyDstBuffer +
-                                              i * nCopyWordsDstStride,
-                                          eBufferDT, 0, 1);
+                            GDALCopyWords64(abyNoData.data(), eBufferDT, 0,
+                                            pabyDstBuffer +
+                                                i * nCopyWordsDstStride,
+                                            eBufferDT, 0, 1);
                         }
                     }
                 }
             }
             else
             {
-                GDALCopyWords(abyNoData.data(), eBufferDT, 0, pabyDstBuffer,
-                              eBufferDT, nCopyWordsDstStride, nCopyWordsCount);
+                GDALCopyWords64(abyNoData.data(), eBufferDT, 0, pabyDstBuffer,
+                                eBufferDT, nCopyWordsDstStride,
+                                nCopyWordsCount);
             }
         }
     }
diff --git a/gcore/gdalnodatamaskband.cpp b/gcore/gdalnodatamaskband.cpp
index 75a391dc1f58..953f100bc96a 100644
--- a/gcore/gdalnodatamaskband.cpp
+++ b/gcore/gdalnodatamaskband.cpp
@@ -539,7 +539,7 @@ CPLErr GDALNoDataMaskBand::IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
 
     for (int iY = 0; iY < nBufYSize; iY++)
     {
-        GDALCopyWords(
+        GDALCopyWords64(
             static_cast<GByte *>(pTemp) + static_cast<size_t>(iY) * nBufXSize,
             GDT_Byte, 1, static_cast<GByte *>(pData) + iY * nLineSpace,
             eBufType, static_cast<int>(nPixelSpace), nBufXSize);
diff --git a/gcore/gdalrasterband.cpp b/gcore/gdalrasterband.cpp
index 91ff7d416f2c..a4665cba021c 100644
--- a/gcore/gdalrasterband.cpp
+++ b/gcore/gdalrasterband.cpp
@@ -9301,8 +9301,8 @@ class GDALMDArrayFromRasterBand final : public GDALMDArray
             if (bHasNoData)
             {
                 m_pabyNoData.resize(m_dt.GetSize());
-                GDALCopyWords(&nNoData, GDT_Int64, 0, &m_pabyNoData[0],
-                              m_dt.GetNumericDataType(), 0, 1);
+                GDALCopyWords64(&nNoData, GDT_Int64, 0, &m_pabyNoData[0],
+                                m_dt.GetNumericDataType(), 0, 1);
             }
         }
         else if (m_poBand->GetRasterDataType() == GDT_UInt64)
@@ -9311,8 +9311,8 @@ class GDALMDArrayFromRasterBand final : public GDALMDArray
             if (bHasNoData)
             {
                 m_pabyNoData.resize(m_dt.GetSize());
-                GDALCopyWords(&nNoData, GDT_UInt64, 0, &m_pabyNoData[0],
-                              m_dt.GetNumericDataType(), 0, 1);
+                GDALCopyWords64(&nNoData, GDT_UInt64, 0, &m_pabyNoData[0],
+                                m_dt.GetNumericDataType(), 0, 1);
             }
         }
         else
@@ -9321,8 +9321,8 @@ class GDALMDArrayFromRasterBand final : public GDALMDArray
             if (bHasNoData)
             {
                 m_pabyNoData.resize(m_dt.GetSize());
-                GDALCopyWords(&dfNoData, GDT_Float64, 0, &m_pabyNoData[0],
-                              m_dt.GetNumericDataType(), 0, 1);
+                GDALCopyWords64(&dfNoData, GDT_Float64, 0, &m_pabyNoData[0],
+                                m_dt.GetNumericDataType(), 0, 1);
             }
         }
 
diff --git a/gcore/overview.cpp b/gcore/overview.cpp
index 84277ffddbd5..d9510dd56634 100644
--- a/gcore/overview.cpp
+++ b/gcore/overview.cpp
@@ -3706,11 +3706,11 @@ static CPLErr GDALResampleChunk_ConvolutionT(
 
         if (pafWrkScanline)
         {
-            GDALCopyWords(pafWrkScanline, eWrkDataType, nWrkDataTypeSize,
-                          static_cast<GByte *>(pDstBuffer) +
-                              static_cast<size_t>(iDstLine - nDstYOff) *
-                                  nDstXSize * nDstDataTypeSize,
-                          dstDataType, nDstDataTypeSize, nDstXSize);
+            GDALCopyWords64(pafWrkScanline, eWrkDataType, nWrkDataTypeSize,
+                            static_cast<GByte *>(pDstBuffer) +
+                                static_cast<size_t>(iDstLine - nDstYOff) *
+                                    nDstXSize * nDstDataTypeSize,
+                            dstDataType, nDstDataTypeSize, nDstXSize);
         }
     }
 
diff --git a/gcore/rasterio.cpp b/gcore/rasterio.cpp
index f95d2018c4de..0f890d7650b4 100644
--- a/gcore/rasterio.cpp
+++ b/gcore/rasterio.cpp
@@ -161,8 +161,8 @@ static bool DownsamplingIntegerXFactor(
         else
         {
             // Type to type conversion ...
-            GDALCopyWords(pabySrcData, eDataType, nIncSrcOffset, pabyDstData,
-                          eBufType, nPixelSpace, std::max(1, nIters));
+            GDALCopyWords64(pabySrcData, eDataType, nIncSrcOffset, pabyDstData,
+                            eBufType, nPixelSpace, std::max(1, nIters));
             if (nIters > 1)
             {
                 pabySrcData +=
@@ -330,18 +330,18 @@ CPLErr GDALRasterBand::IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
                 // Type to type conversion.
 
                 if (eRWFlag == GF_Read)
-                    GDALCopyWords(
+                    GDALCopyWords64(
                         pabySrcBlock + nSrcByteOffset, eDataType, nBandDataSize,
                         static_cast<GByte *>(pData) +
                             static_cast<GPtrDiff_t>(iBufYOff) * nLineSpace,
                         eBufType, static_cast<int>(nPixelSpace), nBufXSize);
                 else
-                    GDALCopyWords(static_cast<GByte *>(pData) +
-                                      static_cast<GPtrDiff_t>(iBufYOff) *
-                                          nLineSpace,
-                                  eBufType, static_cast<int>(nPixelSpace),
-                                  pabySrcBlock + nSrcByteOffset, eDataType,
-                                  nBandDataSize, nBufXSize);
+                    GDALCopyWords64(static_cast<GByte *>(pData) +
+                                        static_cast<GPtrDiff_t>(iBufYOff) *
+                                            nLineSpace,
+                                    eBufType, static_cast<int>(nPixelSpace),
+                                    pabySrcBlock + nSrcByteOffset, eDataType,
+                                    nBandDataSize, nBufXSize);
             }
 
             if (psExtraArg->pfnProgress != nullptr &&
@@ -527,7 +527,7 @@ CPLErr GDALRasterBand::IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
                     {
                         /* type to type conversion */
                         if (eRWFlag == GF_Read)
-                            GDALCopyWords(
+                            GDALCopyWords64(
                                 pabySrcBlock + iSrcOffset, eDataType,
                                 nBandDataSize,
                                 static_cast<GByte *>(pData) + iBufOffset +
@@ -535,7 +535,7 @@ CPLErr GDALRasterBand::IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
                                 eBufType, static_cast<int>(nPixelSpace),
                                 nXSpan);
                         else
-                            GDALCopyWords(
+                            GDALCopyWords64(
                                 static_cast<GByte *>(pData) + iBufOffset +
                                     static_cast<GPtrDiff_t>(k) * nLineSpace,
                                 eBufType, static_cast<int>(nPixelSpace),
@@ -713,9 +713,9 @@ CPLErr GDALRasterBand::IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
                     /* type to type conversion ... ouch, this is expensive way
                     of handling single words */
 
-                    GDALCopyWords(static_cast<GByte *>(pData) + iBufOffset,
-                                  eBufType, 0, pabyDstBlock + iDstOffset,
-                                  eDataType, 0, 1);
+                    GDALCopyWords64(static_cast<GByte *>(pData) + iBufOffset,
+                                    eBufType, 0, pabyDstBlock + iDstOffset,
+                                    eDataType, 0, 1);
                 }
             }
 
@@ -925,9 +925,10 @@ CPLErr GDALRasterBand::IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
                         // Type to type conversion ...
                         GPtrDiff_t iSrcOffset =
                             (nDiffX + iSrcOffsetCst) * nBandDataSize;
-                        GDALCopyWords(pabySrcBlock + iSrcOffset, eDataType, 0,
-                                      static_cast<GByte *>(pData) + iBufOffset,
-                                      eBufType, 0, 1);
+                        GDALCopyWords64(pabySrcBlock + iSrcOffset, eDataType, 0,
+                                        static_cast<GByte *>(pData) +
+                                            iBufOffset,
+                                        eBufType, 0, 1);
                     }
 
                     iBufOffset += static_cast<int>(nPixelSpace);
@@ -1393,12 +1394,13 @@ CPLErr GDALRasterBand::RasterIOResampled(
                         {
                             for (int j = 0; j < nDstYCount; j++)
                             {
-                                GDALCopyWords(&dfNoDataValue, GDT_Float64, 0,
-                                              static_cast<GByte *>(pDataMem) +
-                                                  nLSMem * (j + nDstYOff) +
-                                                  nDstXOff * nPSMem,
-                                              eDTMem, static_cast<int>(nPSMem),
-                                              nDstXCount);
+                                GDALCopyWords64(&dfNoDataValue, GDT_Float64, 0,
+                                                static_cast<GByte *>(pDataMem) +
+                                                    nLSMem * (j + nDstYOff) +
+                                                    nDstXOff * nPSMem,
+                                                eDTMem,
+                                                static_cast<int>(nPSMem),
+                                                nDstXCount);
                             }
                             bSkipResample = true;
                         }
@@ -1856,7 +1858,7 @@ CPLErr GDALDataset::RasterIOResampled(
                             {
                                 for (int j = 0; j < nDstYCount; j++)
                                 {
-                                    GDALCopyWords(
+                                    GDALCopyWords64(
                                         abyZero, GDT_Byte, 0,
                                         static_cast<GByte *>(pData) +
                                             iBand * nBandSpace +
@@ -2955,7 +2957,7 @@ static void GDALReplicateWord(const void *CPL_RESTRICT pSrcData,
      */
     // Let the general translation case do the necessary conversions
     // on the first destination element.
-    GDALCopyWords(pSrcData, eSrcType, 0, pDstData, eDstType, 0, 1);
+    GDALCopyWords64(pSrcData, eSrcType, 0, pDstData, eDstType, 0, 1);
 
     // Now copy the first element to the nWordCount - 1 following destination
     // elements.
@@ -4313,15 +4315,15 @@ CPLErr GDALDataset::BlockBasedRasterIO(
                        of handling single words */
 
                     if (eRWFlag == GF_Read)
-                        GDALCopyWords(pabySrcBlock + iSrcOffset, eDataType, 0,
-                                      static_cast<GByte *>(pData) +
-                                          iBandBufOffset,
-                                      eBufType, 0, 1);
+                        GDALCopyWords64(pabySrcBlock + iSrcOffset, eDataType, 0,
+                                        static_cast<GByte *>(pData) +
+                                            iBandBufOffset,
+                                        eBufType, 0, 1);
                     else
-                        GDALCopyWords(static_cast<const GByte *>(pData) +
-                                          iBandBufOffset,
-                                      eBufType, 0, pabySrcBlock + iSrcOffset,
-                                      eDataType, 0, 1);
+                        GDALCopyWords64(static_cast<const GByte *>(pData) +
+                                            iBandBufOffset,
+                                        eBufType, 0, pabySrcBlock + iSrcOffset,
+                                        eDataType, 0, 1);
                 }
             }
 
diff --git a/gcore/rawdataset.cpp b/gcore/rawdataset.cpp
index 79b68f29edc7..841609137720 100644
--- a/gcore/rawdataset.cpp
+++ b/gcore/rawdataset.cpp
@@ -644,8 +644,8 @@ CPLErr RawRasterBand::IReadBlock(CPL_UNUSED int nBlockXOff, int nBlockYOff,
 
     // Copy data from disk buffer to user block buffer.
     const int nDTSize = GDALGetDataTypeSizeBytes(eDataType);
-    GDALCopyWords(pLineStart, eDataType, nPixelOffset, pImage, eDataType,
-                  nDTSize, nBlockXSize);
+    GDALCopyWords64(pLineStart, eDataType, nPixelOffset, pImage, eDataType,
+                    nDTSize, nBlockXSize);
 
     // Pre-cache block cache of other bands
     if (poDS != nullptr && poDS->GetRasterCount() > 1 && IsBIP())
@@ -666,9 +666,9 @@ CPLErr RawRasterBand::IReadBlock(CPL_UNUSED int nBlockXOff, int nBlockYOff,
                 poBlock = poOtherBand->GetLockedBlockRef(0, nBlockYOff, true);
                 if (poBlock != nullptr)
                 {
-                    GDALCopyWords(poOtherBand->pLineStart, eDataType,
-                                  nPixelOffset, poBlock->GetDataRef(),
-                                  eDataType, nDTSize, nBlockXSize);
+                    GDALCopyWords64(poOtherBand->pLineStart, eDataType,
+                                    nPixelOffset, poBlock->GetDataRef(),
+                                    eDataType, nDTSize, nBlockXSize);
                     poBlock->DropLock();
                 }
             }
@@ -763,8 +763,8 @@ CPLErr RawRasterBand::BIPWriteBlock(int nBlockYOff, int nCallingBand,
 
         GByte *pabyOut = static_cast<GByte *>(pLineStart) + iBand * nDTSize;
 
-        GDALCopyWords(pabyThisImage, eDataType, nDTSize, pabyOut, eDataType,
-                      nPixelOffset, nBlockXSize);
+        GDALCopyWords64(pabyThisImage, eDataType, nDTSize, pabyOut, eDataType,
+                        nPixelOffset, nBlockXSize);
 
         if (poBlock != nullptr)
         {
@@ -823,8 +823,8 @@ CPLErr RawRasterBand::IWriteBlock(CPL_UNUSED int nBlockXOff, int nBlockYOff,
         eErr = AccessLine(nBlockYOff);
 
     // Copy data from user buffer into disk buffer.
-    GDALCopyWords(pImage, eDataType, nDTSize, pLineStart, eDataType,
-                  nPixelOffset, nBlockXSize);
+    GDALCopyWords64(pImage, eDataType, nDTSize, pLineStart, eDataType,
+                    nPixelOffset, nBlockXSize);
 
     nLoadedScanline = nBlockYOff;
     bLoadedScanlineDirty = true;
@@ -1156,7 +1156,7 @@ CPLErr RawRasterBand::IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
                 // subsample, if needed.
                 if (nXSize == nBufXSize && nYSize == nBufYSize)
                 {
-                    GDALCopyWords(
+                    GDALCopyWords64(
                         pabyData, eDataType, nPixelOffset,
                         static_cast<GByte *>(pData) + iLine * nLineSpace,
                         eBufType, static_cast<int>(nPixelSpace), nXSize);
@@ -1165,7 +1165,7 @@ CPLErr RawRasterBand::IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
                 {
                     for (int iPixel = 0; iPixel < nBufXSize; iPixel++)
                     {
-                        GDALCopyWords(
+                        GDALCopyWords64(
                             pabyData + static_cast<vsi_l_offset>(
                                            iPixel * dfSrcXInc + EPS) *
                                            nPixelOffset,
@@ -1283,23 +1283,23 @@ CPLErr RawRasterBand::IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
                 // subsample, if needed.
                 if (nXSize == nBufXSize && nYSize == nBufYSize)
                 {
-                    GDALCopyWords(static_cast<GByte *>(pData) +
-                                      iLine * nLineSpace,
-                                  eBufType, static_cast<int>(nPixelSpace),
-                                  pabyData, eDataType, nPixelOffset, nXSize);
+                    GDALCopyWords64(static_cast<GByte *>(pData) +
+                                        iLine * nLineSpace,
+                                    eBufType, static_cast<int>(nPixelSpace),
+                                    pabyData, eDataType, nPixelOffset, nXSize);
                 }
                 else
                 {
                     for (int iPixel = 0; iPixel < nBufXSize; iPixel++)
                     {
-                        GDALCopyWords(static_cast<GByte *>(pData) +
-                                          iLine * nLineSpace +
-                                          iPixel * nPixelSpace,
-                                      eBufType, static_cast<int>(nPixelSpace),
-                                      pabyData + static_cast<vsi_l_offset>(
-                                                     iPixel * dfSrcXInc + EPS) *
-                                                     nPixelOffset,
-                                      eDataType, nPixelOffset, 1);
+                        GDALCopyWords64(
+                            static_cast<GByte *>(pData) + iLine * nLineSpace +
+                                iPixel * nPixelSpace,
+                            eBufType, static_cast<int>(nPixelSpace),
+                            pabyData + static_cast<vsi_l_offset>(
+                                           iPixel * dfSrcXInc + EPS) *
+                                           nPixelOffset,
+                            eDataType, nPixelOffset, 1);
                     }
                 }
 

From 67f7823f107860f172bfd15e30fb9b154fc31410 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Fri, 3 Jan 2025 04:38:08 +0100
Subject: [PATCH 19/40] VRTProcessedDataset: reduce block size when amount of
 RAM for temp buffers would be too large

---
 frmts/vrt/vrtprocesseddataset.cpp | 77 +++++++++++++++++++++++++++++++
 1 file changed, 77 insertions(+)

diff --git a/frmts/vrt/vrtprocesseddataset.cpp b/frmts/vrt/vrtprocesseddataset.cpp
index 27ee1a437f69..546a9d5cfdb7 100644
--- a/frmts/vrt/vrtprocesseddataset.cpp
+++ b/frmts/vrt/vrtprocesseddataset.cpp
@@ -301,12 +301,29 @@ CPLErr VRTProcessedDataset::Init(const CPLXMLNode *psTree,
 
     const auto poSrcFirstBand = m_poSrcDS->GetRasterBand(1);
     poSrcFirstBand->GetBlockSize(&m_nBlockXSize, &m_nBlockYSize);
+    bool bUserBlockSize = false;
     if (const char *pszBlockXSize =
             CPLGetXMLValue(psTree, "BlockXSize", nullptr))
+    {
+        bUserBlockSize = true;
         m_nBlockXSize = atoi(pszBlockXSize);
+        if (m_nBlockXSize <= 1)
+        {
+            CPLError(CE_Failure, CPLE_AppDefined, "Invalid BlockXSize");
+            return CE_Failure;
+        }
+    }
     if (const char *pszBlockYSize =
             CPLGetXMLValue(psTree, "BlockYSize", nullptr))
+    {
+        bUserBlockSize = true;
         m_nBlockYSize = atoi(pszBlockYSize);
+        if (m_nBlockYSize <= 1)
+        {
+            CPLError(CE_Failure, CPLE_AppDefined, "Invalid BlockYSize");
+            return CE_Failure;
+        }
+    }
 
     // Initialize all the general VRT stuff.
     if (VRTDataset::XMLInit(psTree, pszVRTPathIn) != CE_None)
@@ -521,6 +538,66 @@ CPLErr VRTProcessedDataset::Init(const CPLXMLNode *psTree,
         return CE_Failure;
     }
 
+    // Use only up to 40% of RAM to acquire source bands and generate the output
+    // buffer.
+    const auto nMaxMemAllowed = CPLGetUsablePhysicalRAM() / 10 * 4;
+    if (nMaxMemAllowed > 0)
+    {
+        int nLargestInDTSizeTimesBand = 1;
+        int nLargestOutDTSizeTimesBand = 1;
+        for (const auto &oStep : m_aoSteps)
+        {
+            const int nInDTSizeTimesBand =
+                GDALGetDataTypeSizeBytes(oStep.eInDT) * oStep.nInBands;
+            nLargestInDTSizeTimesBand =
+                std::max(nLargestInDTSizeTimesBand, nInDTSizeTimesBand);
+            const int nOutDTSizeTimesBand =
+                GDALGetDataTypeSizeBytes(oStep.eOutDT) * oStep.nOutBands;
+            nLargestOutDTSizeTimesBand =
+                std::max(nLargestOutDTSizeTimesBand, nOutDTSizeTimesBand);
+        }
+
+        const int nPerPixelSize =
+            nLargestInDTSizeTimesBand + nLargestOutDTSizeTimesBand;
+
+        bool bBlockSizeModified = false;
+        while ((m_nBlockXSize >= 2 || m_nBlockYSize >= 2) &&
+               static_cast<GIntBig>(m_nBlockXSize) * m_nBlockYSize >
+                   nMaxMemAllowed / nPerPixelSize)
+        {
+            if ((m_nBlockXSize == nRasterXSize ||
+                 m_nBlockYSize >= m_nBlockXSize) &&
+                m_nBlockYSize >= 2)
+            {
+                m_nBlockYSize /= 2;
+            }
+            else
+            {
+                m_nBlockXSize /= 2;
+            }
+            bBlockSizeModified = true;
+        }
+        if (bBlockSizeModified)
+        {
+            if (bUserBlockSize)
+            {
+                CPLError(
+                    CE_Warning, CPLE_AppDefined,
+                    "Reducing block size to %d x %d to avoid consuming too "
+                    "much RAM",
+                    m_nBlockXSize, m_nBlockYSize);
+            }
+            else
+            {
+                CPLDebug(
+                    "VRT",
+                    "Reducing block size to %d x %d to avoid consuming too "
+                    "much RAM",
+                    m_nBlockXSize, m_nBlockYSize);
+            }
+        }
+    }
+
     if (m_outputBandCountProvenance == ValueProvenance::FROM_LAST_STEP)
     {
         nOutputBandCount = nCurrentBandCount;

From d4779d4687be9e0050b03835303603f6d7f6a73a Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Fri, 3 Jan 2025 15:34:17 +0100
Subject: [PATCH 20/40] GDALMDArray::AsClassicDataset(): allow to set band
 IMAGERY metadata domain

Add a BAND_IMAGERY_METADATA options to papszOptions:

JSON serialized object defining which arrays of the
poRootGroup, indexed by non-X and Y dimensions,
should be mapped as band metadata items in the
band IMAGERY domain.
The object currently accepts 2 members:
- "CENTRAL_WAVELENGTH_UM": Central Wavelength in
  micrometers.
- "FWHM_UM": Full-width half-maximum
  in micrometers.

The value of each member should be an object with the
following members:
- "array": (required) full name of a band parameter
  array.
  Such array must be a one dimensional array, and its
  dimension must be one of the dimensions of the
  array on which the method is called
  (excluding the X and Y dimensons).
- "unit": (optional) unit of the values pointed in
  the above array.
  Can be a literal string or a string of the form
  "${attribute_name}" to point to an attribute for
  the array.
  Accepted values are "um", "micrometer"
  (with UK vs US spelling, singular or plural), "nm",
  "nanometer" (with UK vs US spelling, singular or
  plural)
  If not provided, micrometer is assumed.

Example for EMIT datasets:
```json
{
   "CENTRAL_WAVELENGTH_UM": {
       "array": "/sensor_band_parameters/wavelengths",
       "unit": "${units}"
   },
   "FWHM_UM": {
       "array": "/sensor_band_parameters/fwhm",
       "unit": "${units}"
   }
}
```
---
 autotest/gcore/multidim.py | 130 +++++++++++++++++
 gcore/gdalmultidim.cpp     | 284 ++++++++++++++++++++++++++++++++++---
 2 files changed, 396 insertions(+), 18 deletions(-)

diff --git a/autotest/gcore/multidim.py b/autotest/gcore/multidim.py
index 0cf75f777868..d25b0be84a63 100644
--- a/autotest/gcore/multidim.py
+++ b/autotest/gcore/multidim.py
@@ -797,6 +797,136 @@ def test_multidim_asclassicsubdataset_band_metadata():
     }
 
 
+@gdaltest.enable_exceptions()
+def test_multidim_asclassicsubdataset_band_imagery_metadata():
+
+    drv = gdal.GetDriverByName("MEM")
+    mem_ds = drv.CreateMultiDimensional("myds")
+    rg = mem_ds.GetRootGroup()
+
+    dimOther = rg.CreateDimension("other", None, None, 2)
+
+    other = rg.CreateMDArray(
+        "other", [dimOther], gdal.ExtendedDataType.Create(gdal.GDT_Float64)
+    )
+    other.Write(array.array("d", [10.5, 20]))
+
+    fwhm = rg.CreateMDArray(
+        "fwhm", [dimOther], gdal.ExtendedDataType.Create(gdal.GDT_Float64)
+    )
+    fwhm.Write(array.array("d", [3.5, 4.5]))
+
+    string_attr = other.CreateAttribute(
+        "string_attr", [], gdal.ExtendedDataType.CreateString()
+    )
+    assert string_attr.Write("nm") == gdal.CE_None
+
+    dimX = rg.CreateDimension("X", None, None, 2)
+    X = rg.CreateMDArray("X", [dimX], gdal.ExtendedDataType.Create(gdal.GDT_Float64))
+    X.Write(array.array("d", [10, 20]))
+    dimX.SetIndexingVariable(X)
+    dimY = rg.CreateDimension("Y", None, None, 2)
+
+    ar = rg.CreateMDArray(
+        "ar", [dimOther, dimY, dimX], gdal.ExtendedDataType.Create(gdal.GDT_Float64)
+    )
+
+    with pytest.raises(
+        Exception,
+        match="Root group should be provided when BAND_IMAGERY_METADATA is set",
+    ):
+        ar.AsClassicDataset(2, 1, None, ["BAND_IMAGERY_METADATA={}"])
+
+    with pytest.raises(
+        Exception, match="Invalid JSON content for BAND_IMAGERY_METADATA"
+    ):
+        ar.AsClassicDataset(2, 1, rg, ["BAND_IMAGERY_METADATA=invalid"])
+
+    with pytest.raises(
+        Exception, match="Value of BAND_IMAGERY_METADATA should be an object"
+    ):
+        ar.AsClassicDataset(2, 1, rg, ["BAND_IMAGERY_METADATA=false"])
+
+    band_metadata = {"CENTRAL_WAVELENGTH_UM": {}}
+    with pytest.raises(
+        Exception,
+        match=r'BAND_IMAGERY_METADATA\["CENTRAL_WAVELENGTH_UM"\]\["array"\] is missing',
+    ):
+        ds = ar.AsClassicDataset(
+            2, 1, rg, ["BAND_IMAGERY_METADATA=" + json.dumps(band_metadata)]
+        )
+
+    band_metadata = {"CENTRAL_WAVELENGTH_UM": {"array": "/i/do/not/exist"}}
+    with pytest.raises(Exception, match="Array /i/do/not/exist cannot be found"):
+        ds = ar.AsClassicDataset(
+            2, 1, rg, ["BAND_IMAGERY_METADATA=" + json.dumps(band_metadata)]
+        )
+
+    band_metadata = {"CENTRAL_WAVELENGTH_UM": {"array": "/ar"}}
+    with pytest.raises(Exception, match="Array /ar is not a 1D array"):
+        ds = ar.AsClassicDataset(
+            2, 1, rg, ["BAND_IMAGERY_METADATA=" + json.dumps(band_metadata)]
+        )
+
+    band_metadata = {"CENTRAL_WAVELENGTH_UM": {"array": "/X"}}
+    with pytest.raises(
+        Exception,
+        match='Dimension "X" of array "/X" is not a non-X/Y dimension of array "ar"',
+    ):
+        ds = ar.AsClassicDataset(
+            2, 1, rg, ["BAND_IMAGERY_METADATA=" + json.dumps(band_metadata)]
+        )
+
+    band_metadata = {"CENTRAL_WAVELENGTH_UM": {"array": "/other", "unit": "${invalid"}}
+    with pytest.raises(
+        Exception,
+        match=r'Value of BAND_IMAGERY_METADATA\["CENTRAL_WAVELENGTH_UM"\]\["unit"\] = \${invalid is invalid',
+    ):
+        ds = ar.AsClassicDataset(
+            2, 1, rg, ["BAND_IMAGERY_METADATA=" + json.dumps(band_metadata)]
+        )
+
+    band_metadata = {"CENTRAL_WAVELENGTH_UM": {"array": "/other", "unit": "${invalid}"}}
+    with pytest.raises(
+        Exception,
+        match=r'Value of BAND_IMAGERY_METADATA\["CENTRAL_WAVELENGTH_UM"\]\["unit"\] = \${invalid} is invalid: invalid is not an attribute of \/other',
+    ):
+        ds = ar.AsClassicDataset(
+            2, 1, rg, ["BAND_IMAGERY_METADATA=" + json.dumps(band_metadata)]
+        )
+
+    band_metadata = {"CENTRAL_WAVELENGTH_UM": {"array": "/other", "unit": "unhandled"}}
+    with pytest.raises(
+        Exception,
+        match=r'Unhandled value for BAND_IMAGERY_METADATA\["CENTRAL_WAVELENGTH_UM"\]\["unit"\] = unhandled',
+    ):
+        ds = ar.AsClassicDataset(
+            2, 1, rg, ["BAND_IMAGERY_METADATA=" + json.dumps(band_metadata)]
+        )
+
+    band_metadata = {"ignored": {}}
+    with gdal.quiet_errors():
+        ar.AsClassicDataset(
+            2, 1, rg, ["BAND_IMAGERY_METADATA=" + json.dumps(band_metadata)]
+        )
+
+    band_metadata = {
+        "CENTRAL_WAVELENGTH_UM": {"array": "/other", "unit": "${string_attr}"},
+        "FWHM_UM": {"array": "/fwhm"},
+    }
+    ds = ar.AsClassicDataset(
+        2, 1, rg, ["BAND_IMAGERY_METADATA=" + json.dumps(band_metadata)]
+    )
+    assert ds.GetRasterBand(1).GetMetadata("IMAGERY") == {
+        "CENTRAL_WAVELENGTH_UM": "0.0105",
+        "FWHM_UM": "3.5",
+    }
+    assert ds.GetRasterBand(2).GetMetadata("IMAGERY") == {
+        "CENTRAL_WAVELENGTH_UM": "0.02",
+        "FWHM_UM": "4.5",
+    }
+
+
 @gdaltest.enable_exceptions()
 def test_multidim_SubsetDimensionFromSelection():
 
diff --git a/gcore/gdalmultidim.cpp b/gcore/gdalmultidim.cpp
index b26384a35b91..bc884b55edf5 100644
--- a/gcore/gdalmultidim.cpp
+++ b/gcore/gdalmultidim.cpp
@@ -8551,6 +8551,15 @@ struct MetadataItem
     std::string osDefinition{};
     bool bDefinitionUsesPctForG = false;
 };
+
+struct BandImageryMetadata
+{
+    std::shared_ptr<GDALMDArray> poCentralWavelengthArray{};
+    double dfCentralWavelengthToMicrometer = 1.0;
+    std::shared_ptr<GDALMDArray> poFWHMArray{};
+    double dfFWHMToMicrometer = 1.0;
+};
+
 }  // namespace
 
 class GDALRasterBandFromArray final : public GDALPamRasterBand
@@ -8574,6 +8583,7 @@ class GDALRasterBandFromArray final : public GDALPamRasterBand
         const std::vector<GUInt64> &anOtherDimCoord,
         const std::vector<std::vector<MetadataItem>>
             &aoBandParameterMetadataItems,
+        const std::vector<BandImageryMetadata> &aoBandImageryMetadata,
         double dfDelay, time_t nStartTime, bool &bHasWarned);
 
     double GetNoDataValue(int *pbHasNoData) override;
@@ -8707,6 +8717,7 @@ class GDALDatasetFromArray final : public GDALPamDataset
 GDALRasterBandFromArray::GDALRasterBandFromArray(
     GDALDatasetFromArray *poDSIn, const std::vector<GUInt64> &anOtherDimCoord,
     const std::vector<std::vector<MetadataItem>> &aoBandParameterMetadataItems,
+    const std::vector<BandImageryMetadata> &aoBandImageryMetadata,
     double dfDelay, time_t nStartTime, bool &bHasWarned)
 {
     const auto &poArray(poDSIn->m_poArray);
@@ -8878,6 +8889,51 @@ GDALRasterBandFromArray::GDALRasterBandFromArray(
                     SetMetadataItem(oItem.osName.c_str(), osVal);
             }
 
+            if (aoBandImageryMetadata[j].poCentralWavelengthArray)
+            {
+                auto &poCentralWavelengthArray =
+                    aoBandImageryMetadata[j].poCentralWavelengthArray;
+                size_t nCount = 1;
+                const auto &dt(poCentralWavelengthArray->GetDataType());
+                std::vector<GByte> abyTmp(dt.GetSize());
+                if (poCentralWavelengthArray->Read(&(anOtherDimCoord[j]),
+                                                   &nCount, nullptr, nullptr,
+                                                   dt, &abyTmp[0]))
+                {
+                    double dfVal = 0;
+                    GDALExtendedDataType::CopyValue(
+                        &abyTmp[0], dt, &dfVal,
+                        GDALExtendedDataType::Create(GDT_Float64));
+                    SetMetadataItem(
+                        "CENTRAL_WAVELENGTH_UM",
+                        CPLSPrintf(
+                            "%g", dfVal * aoBandImageryMetadata[j]
+                                              .dfCentralWavelengthToMicrometer),
+                        "IMAGERY");
+                }
+            }
+
+            if (aoBandImageryMetadata[j].poFWHMArray)
+            {
+                auto &poFWHMArray = aoBandImageryMetadata[j].poFWHMArray;
+                size_t nCount = 1;
+                const auto &dt(poFWHMArray->GetDataType());
+                std::vector<GByte> abyTmp(dt.GetSize());
+                if (poFWHMArray->Read(&(anOtherDimCoord[j]), &nCount, nullptr,
+                                      nullptr, dt, &abyTmp[0]))
+                {
+                    double dfVal = 0;
+                    GDALExtendedDataType::CopyValue(
+                        &abyTmp[0], dt, &dfVal,
+                        GDALExtendedDataType::Create(GDT_Float64));
+                    SetMetadataItem(
+                        "FWHM_UM",
+                        CPLSPrintf("%g", dfVal * aoBandImageryMetadata[j]
+                                                     .dfFWHMToMicrometer),
+                        "IMAGERY");
+                }
+            }
+
             m_anOffset[i] = anOtherDimCoord[j];
             j++;
         }
@@ -9161,12 +9217,22 @@ GDALDatasetFromArray *GDALDatasetFromArray::Create(
         }
     }
 
+    std::map<std::string, size_t> oMapArrayDimNameToExtraDimIdx;
+    for (size_t i = 0, j = 0; i < nDimCount; ++i)
+    {
+        if (i != iXDim && !(nDimCount >= 2 && i == iYDim))
+        {
+            oMapArrayDimNameToExtraDimIdx[dims[i]->GetName()] = j;
+            ++j;
+        }
+    }
+
+    const size_t nNewDimCount = nDimCount >= 2 ? nDimCount - 2 : 0;
+
     const char *pszBandMetadata =
         CSLFetchNameValue(papszOptions, "BAND_METADATA");
-    const size_t nNewDimCount = nDimCount >= 2 ? nDimCount - 2 : 0;
     std::vector<std::vector<MetadataItem>> aoBandParameterMetadataItems(
         nNewDimCount);
-
     if (pszBandMetadata)
     {
         if (!poRootGroup)
@@ -9190,16 +9256,6 @@ GDALDatasetFromArray *GDALDatasetFromArray::Create(
             return nullptr;
         }
 
-        std::map<std::string, size_t> oMapArrayDimNameToExtraDimIdx;
-        for (size_t i = 0, j = 0; i < nDimCount; ++i)
-        {
-            if (i != iXDim && !(nDimCount >= 2 && i == iYDim))
-            {
-                oMapArrayDimNameToExtraDimIdx[dims[i]->GetName()] = j;
-                ++j;
-            }
-        }
-
         auto oArray = oRoot.ToArray();
         for (int j = 0; j < oArray.Size(); ++j)
         {
@@ -9382,6 +9438,155 @@ GDALDatasetFromArray *GDALDatasetFromArray::Create(
         }
     }
 
+    std::vector<BandImageryMetadata> aoBandImageryMetadata(nNewDimCount);
+    const char *pszBandImageryMetadata =
+        CSLFetchNameValue(papszOptions, "BAND_IMAGERY_METADATA");
+    if (pszBandImageryMetadata)
+    {
+        if (!poRootGroup)
+        {
+            CPLError(CE_Failure, CPLE_AppDefined,
+                     "Root group should be provided when BAND_IMAGERY_METADATA "
+                     "is set");
+            return nullptr;
+        }
+        CPLJSONDocument oDoc;
+        if (!oDoc.LoadMemory(pszBandImageryMetadata))
+        {
+            CPLError(CE_Failure, CPLE_AppDefined,
+                     "Invalid JSON content for BAND_IMAGERY_METADATA");
+            return nullptr;
+        }
+        auto oRoot = oDoc.GetRoot();
+        if (oRoot.GetType() != CPLJSONObject::Type::Object)
+        {
+            CPLError(CE_Failure, CPLE_AppDefined,
+                     "Value of BAND_IMAGERY_METADATA should be an object");
+            return nullptr;
+        }
+        for (const auto &oJsonItem : oRoot.GetChildren())
+        {
+            if (oJsonItem.GetName() == "CENTRAL_WAVELENGTH_UM" ||
+                oJsonItem.GetName() == "FWHM_UM")
+            {
+                auto osBandArrayFullname = oJsonItem.GetString("array");
+                if (osBandArrayFullname.empty())
+                {
+                    CPLError(
+                        CE_Failure, CPLE_AppDefined,
+                        "BAND_IMAGERY_METADATA[\"%s\"][\"array\"] is missing",
+                        oJsonItem.GetName().c_str());
+                    return nullptr;
+                }
+                auto poArray =
+                    poRootGroup->OpenMDArrayFromFullname(osBandArrayFullname);
+                if (!poArray)
+                {
+                    CPLError(CE_Failure, CPLE_AppDefined,
+                             "Array %s cannot be found",
+                             osBandArrayFullname.c_str());
+                    return nullptr;
+                }
+                if (poArray->GetDimensionCount() != 1)
+                {
+                    CPLError(CE_Failure, CPLE_AppDefined,
+                             "Array %s is not a 1D array",
+                             osBandArrayFullname.c_str());
+                    return nullptr;
+                }
+                const auto &osAuxArrayDimName =
+                    poArray->GetDimensions()[0]->GetName();
+                auto oIter =
+                    oMapArrayDimNameToExtraDimIdx.find(osAuxArrayDimName);
+                if (oIter == oMapArrayDimNameToExtraDimIdx.end())
+                {
+                    CPLError(CE_Failure, CPLE_AppDefined,
+                             "Dimension \"%s\" of array \"%s\" is not a "
+                             "non-X/Y dimension of array \"%s\"",
+                             osAuxArrayDimName.c_str(),
+                             osBandArrayFullname.c_str(),
+                             array->GetName().c_str());
+                    return nullptr;
+                }
+                const size_t iExtraDimIdx = oIter->second;
+                CPLAssert(iExtraDimIdx < nNewDimCount);
+
+                std::string osUnit = oJsonItem.GetString("unit", "um");
+                if (STARTS_WITH(osUnit.c_str(), "${"))
+                {
+                    if (osUnit.back() != '}')
+                    {
+                        CPLError(CE_Failure, CPLE_AppDefined,
+                                 "Value of "
+                                 "BAND_IMAGERY_METADATA[\"%s\"][\"unit\"] = "
+                                 "%s is invalid",
+                                 oJsonItem.GetName().c_str(), osUnit.c_str());
+                        return nullptr;
+                    }
+                    const auto osAttrName = osUnit.substr(2, osUnit.size() - 3);
+                    auto poAttr = poArray->GetAttribute(osAttrName);
+                    if (!poAttr)
+                    {
+                        CPLError(CE_Failure, CPLE_AppDefined,
+                                 "Value of "
+                                 "BAND_IMAGERY_METADATA[\"%s\"][\"unit\"] = "
+                                 "%s is invalid: %s is not an attribute of %s",
+                                 oJsonItem.GetName().c_str(), osUnit.c_str(),
+                                 osAttrName.c_str(),
+                                 osBandArrayFullname.c_str());
+                        return nullptr;
+                    }
+                    const char *pszValue = poAttr->ReadAsString();
+                    if (!pszValue)
+                    {
+                        CPLError(CE_Failure, CPLE_AppDefined,
+                                 "Cannot get value of attribute %s of %s as a "
+                                 "string",
+                                 osAttrName.c_str(),
+                                 osBandArrayFullname.c_str());
+                        return nullptr;
+                    }
+                    osUnit = pszValue;
+                }
+                double dfConvToUM = 1.0;
+                if (osUnit == "nm" || osUnit == "nanometre" ||
+                    osUnit == "nanometres" || osUnit == "nanometer" ||
+                    osUnit == "nanometers")
+                {
+                    dfConvToUM = 1e-3;
+                }
+                else if (!(osUnit == "um" || osUnit == "micrometre" ||
+                           osUnit == "micrometres" || osUnit == "micrometer" ||
+                           osUnit == "micrometers"))
+                {
+                    CPLError(CE_Failure, CPLE_AppDefined,
+                             "Unhandled value for "
+                             "BAND_IMAGERY_METADATA[\"%s\"][\"unit\"] = %s",
+                             oJsonItem.GetName().c_str(), osUnit.c_str());
+                    return nullptr;
+                }
+
+                BandImageryMetadata &item = aoBandImageryMetadata[iExtraDimIdx];
+                if (oJsonItem.GetName() == "CENTRAL_WAVELENGTH_UM")
+                {
+                    item.poCentralWavelengthArray = poArray;
+                    item.dfCentralWavelengthToMicrometer = dfConvToUM;
+                }
+                else
+                {
+                    item.poFWHMArray = poArray;
+                    item.dfFWHMToMicrometer = dfConvToUM;
+                }
+            }
+            else
+            {
+                CPLError(CE_Warning, CPLE_AppDefined,
+                         "Ignored member \"%s\" in BAND_IMAGERY_METADATA",
+                         oJsonItem.GetName().c_str());
+            }
+        }
+    }
+
     auto poDS = std::make_unique<GDALDatasetFromArray>(array, iXDim, iYDim);
 
     poDS->eAccess = array->IsWritable() ? GA_Update : GA_ReadOnly;
@@ -9462,10 +9667,11 @@ GDALDatasetFromArray *GDALDatasetFromArray::Create(
     }
     else
     {
-        poDS->SetBand(nCurBand, new GDALRasterBandFromArray(
-                                    poDS.get(), anOtherDimCoord,
-                                    aoBandParameterMetadataItems, dfDelay,
-                                    nStartTime, bHasWarned));
+        poDS->SetBand(nCurBand,
+                      new GDALRasterBandFromArray(
+                          poDS.get(), anOtherDimCoord,
+                          aoBandParameterMetadataItems, aoBandImageryMetadata,
+                          dfDelay, nStartTime, bHasWarned));
         ++nCurBand;
     }
     if (iDim > 0)
@@ -9513,7 +9719,7 @@ GDALDatasetFromArray *GDALDatasetFromArray::Create(
  * @param iYDim Index of the dimension that will be used as the Y/height axis.
  *              Ignored if the dimension count is 1.
  * @param poRootGroup (Added in GDAL 3.8) Root group. Used with the BAND_METADATA
- *                    option.
+ *                    and BAND_IMAGERY_METADATA option.
  * @param papszOptions (Added in GDAL 3.8) Null-terminated list of options, or
  *                     nullptr. Current supported options are:
  *                     <ul>
@@ -9556,6 +9762,47 @@ GDALDatasetFromArray *GDALDatasetFromArray::Create(
  *                            }
  *                         ]
  *                     </li>
+ *                     <li>BAND_IMAGERY_METADATA: (GDAL >= 3.11)
+ *                         JSON serialized object defining which arrays of the
+ *                         poRootGroup, indexed by non-X and Y dimensions,
+ *                         should be mapped as band metadata items in the
+ *                         band IMAGERY domain.
+ *                         The object currently accepts 2 members:
+ *                         - "CENTRAL_WAVELENGTH_UM": Central Wavelength in
+ *                           micrometers.
+ *                         - "FWHM_UM": Full-width half-maximum
+ *                           in micrometers.
+ *                         The value of each member should be an object with the
+ *                         following members:
+ *                         - "array": (required) full name of a band parameter
+ *                           array.
+ *                           Such array must be a one dimensional array, and its
+ *                           dimension must be one of the dimensions of the
+ *                           array on which the method is called
+ *                           (excluding the X and Y dimensons).
+ *                         - "unit": (optional) unit of the values pointed in
+ *                           the above array.
+ *                           Can be a literal string or a string of the form
+ *                           "${attribute_name}" to point to an attribute for
+ *                           the array.
+ *                           Accepted values are "um", "micrometer"
+ *                           (with UK vs US spelling, singular or plural), "nm",
+ *                           "nanometer" (with UK vs US spelling, singular or
+ *                           plural)
+ *                           If not provided, micrometer is assumed.
+ *
+ *                         Example for EMIT datasets:
+ *                         {
+ *                            "CENTRAL_WAVELENGTH_UM": {
+ *                                "array": "/sensor_band_parameters/wavelengths",
+ *                                "unit": "${units}"
+ *                            },
+ *                            "FWHM_UM": {
+ *                                "array": "/sensor_band_parameters/fwhm",
+ *                                "unit": "${units}"
+ *                            }
+ *                         }
+ *                     </li>
  *                     <li>LOAD_EXTRA_DIM_METADATA_DELAY: Maximum delay in
  *                         seconds allowed to set the DIM_{dimname}_VALUE band
  *                         metadata items from the indexing variable of the
@@ -13594,7 +13841,8 @@ GDALDatasetH GDALMDArrayAsClassicDataset(GDALMDArrayH hArray, size_t iXDim,
  * @param iXDim Index of the dimension that will be used as the X/width axis.
  * @param iYDim Index of the dimension that will be used as the Y/height axis.
  *              Ignored if the dimension count is 1.
- * @param hRootGroup Root group, or NULL. Used with the BAND_METADATA option.
+ * @param hRootGroup Root group, or NULL. Used with the BAND_METADATA and
+ *                   BAND_IMAGERY_METADATA option.
  * @param papszOptions Cf GDALMDArray::AsClassicDataset()
  * @return a new GDALDataset that must be freed with GDALClose(), or nullptr
  * @since GDAL 3.8

From 931e43afe0d19ad9203570787e25fd05c03b237d Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Fri, 3 Jan 2025 18:24:47 +0100
Subject: [PATCH 21/40] Add GDALTranspose2D() for fast 2D matrix transposition

---
 autotest/cpp/test_gdal.cpp      |  38 +++++++
 doc/source/api/raster_c_api.rst |   9 ++
 gcore/gdal.h                    |   4 +
 gcore/gdal_priv_templates.hpp   | 175 ++++++++++++++++++++++++++++----
 gcore/rasterio.cpp              | 114 +++++++++++++++++++++
 5 files changed, 323 insertions(+), 17 deletions(-)

diff --git a/autotest/cpp/test_gdal.cpp b/autotest/cpp/test_gdal.cpp
index 88a2e9d4a9e3..5b3289cf66ce 100644
--- a/autotest/cpp/test_gdal.cpp
+++ b/autotest/cpp/test_gdal.cpp
@@ -4951,4 +4951,42 @@ TEST_F(test_gdal, GDALComputeRasterMinMaxLocation_with_mask)
     EXPECT_EQ(nMaxY, 0);
 }
 
+TEST_F(test_gdal, GDALTranspose2D)
+{
+    constexpr int COUNT = 6;
+    const GByte abyData[] = {1, 2, 3, 4, 5, 6};
+    GByte abySrcData[COUNT * 2 * sizeof(double)];
+    GByte abyDstData[COUNT * 2 * sizeof(double)];
+    GByte abyDstAsByteData[COUNT * 2 * sizeof(double)];
+    for (int eSrcDTInt = GDT_Byte; eSrcDTInt < GDT_TypeCount; ++eSrcDTInt)
+    {
+        const auto eSrcDT = static_cast<GDALDataType>(eSrcDTInt);
+        GDALCopyWords(abyData, GDT_Byte, 1, abySrcData, eSrcDT,
+                      GDALGetDataTypeSizeBytes(eSrcDT), COUNT);
+        for (int eDstDTInt = GDT_Byte; eDstDTInt < GDT_TypeCount; ++eDstDTInt)
+        {
+            const auto eDstDT = static_cast<GDALDataType>(eDstDTInt);
+            memset(abyDstData, 0, sizeof(abyDstData));
+            GDALTranspose2D(abySrcData, eSrcDT, abyDstData, eDstDT, 3, 2);
+
+            memset(abyDstAsByteData, 0, sizeof(abyDstAsByteData));
+            GDALCopyWords(abyDstData, eDstDT, GDALGetDataTypeSizeBytes(eDstDT),
+                          abyDstAsByteData, GDT_Byte, 1, COUNT);
+
+            EXPECT_EQ(abyDstAsByteData[0], 1)
+                << "eSrcDT=" << eSrcDT << ", eDstDT=" << eDstDT;
+            EXPECT_EQ(abyDstAsByteData[1], 4)
+                << "eSrcDT=" << eSrcDT << ", eDstDT=" << eDstDT;
+            EXPECT_EQ(abyDstAsByteData[2], 2)
+                << "eSrcDT=" << eSrcDT << ", eDstDT=" << eDstDT;
+            EXPECT_EQ(abyDstAsByteData[3], 5)
+                << "eSrcDT=" << eSrcDT << ", eDstDT=" << eDstDT;
+            EXPECT_EQ(abyDstAsByteData[4], 3)
+                << "eSrcDT=" << eSrcDT << ", eDstDT=" << eDstDT;
+            EXPECT_EQ(abyDstAsByteData[5], 6)
+                << "eSrcDT=" << eSrcDT << ", eDstDT=" << eDstDT;
+        }
+    }
+}
+
 }  // namespace
diff --git a/doc/source/api/raster_c_api.rst b/doc/source/api/raster_c_api.rst
index feb6477d9d44..8c2dc9b73209 100644
--- a/doc/source/api/raster_c_api.rst
+++ b/doc/source/api/raster_c_api.rst
@@ -11,3 +11,12 @@ gdal.h: Raster C API
 
 .. doxygenfile:: gdal.h
    :project: api
+
+
+.. below is an allow-list for spelling checker.
+
+.. spelling:word-list::
+     nSrcHeight
+     nSrcWidth
+     pSrc
+     pDst
diff --git a/gcore/gdal.h b/gcore/gdal.h
index c8d00745832c..8a8f414a826d 100644
--- a/gcore/gdal.h
+++ b/gcore/gdal.h
@@ -1941,6 +1941,10 @@ void CPL_DLL GDALDeinterleave(const void *pSourceBuffer, GDALDataType eSourceDT,
                               int nComponents, void **ppDestBuffer,
                               GDALDataType eDestDT, size_t nIters);
 
+void CPL_DLL GDALTranspose2D(const void *pSrc, GDALDataType eSrcType,
+                             void *pDst, GDALDataType eDstType,
+                             size_t nSrcWidth, size_t nSrcHeight);
+
 double CPL_DLL GDALGetNoDataReplacementValue(GDALDataType, double);
 
 int CPL_DLL CPL_STDCALL GDALLoadWorldFile(const char *, double *);
diff --git a/gcore/gdal_priv_templates.hpp b/gcore/gdal_priv_templates.hpp
index e82a942dd52c..e9ca6f828272 100644
--- a/gcore/gdal_priv_templates.hpp
+++ b/gcore/gdal_priv_templates.hpp
@@ -6,6 +6,7 @@
  *
  ******************************************************************************
  * Copyright (c) 2009, Phil Vachon, <philippe at cowpig.ca>
+ * Copyright (c) 2025, Even Rouault, <even.rouault at spatialys.com>
  *
  * SPDX-License-Identifier: MIT
  ****************************************************************************/
@@ -15,9 +16,11 @@
 
 #include "cpl_port.h"
 
+#include <algorithm>
 #include <cmath>
 #include <cstdint>
 #include <limits>
+#include <type_traits>
 
 /************************************************************************/
 /*                        GDALGetDataLimits()                           */
@@ -224,22 +227,6 @@ template <class Tin> struct sGDALCopyWord<Tin, double>
     }
 };
 
-template <> struct sGDALCopyWord<double, double>
-{
-    static inline void f(const double dfValueIn, double &dfValueOut)
-    {
-        dfValueOut = dfValueIn;
-    }
-};
-
-template <> struct sGDALCopyWord<float, float>
-{
-    static inline void f(const float fValueIn, float &fValueOut)
-    {
-        fValueOut = fValueIn;
-    }
-};
-
 template <> struct sGDALCopyWord<float, double>
 {
     static inline void f(const float fValueIn, double &dfValueOut)
@@ -542,7 +529,10 @@ template <> struct sGDALCopyWord<float, std::uint64_t>
 template <class Tin, class Tout>
 inline void GDALCopyWord(const Tin tValueIn, Tout &tValueOut)
 {
-    sGDALCopyWord<Tin, Tout>::f(tValueIn, tValueOut);
+    if constexpr (std::is_same<Tin, Tout>::value)
+        tValueOut = tValueIn;
+    else
+        sGDALCopyWord<Tin, Tout>::f(tValueIn, tValueOut);
 }
 
 /************************************************************************/
@@ -788,4 +778,155 @@ inline void GDALCopy4Words(const double *pValueIn, float *const pValueOut)
 
 #endif  //  defined(__x86_64) || defined(_M_X64)
 
+/************************************************************************/
+/*                    GDALTranspose2DSingleToSingle()                   */
+/************************************************************************/
+/**
+ * Transpose a 2D array of non-complex values, in a efficient (cache-oblivious) way.
+ *
+ * @param pSrc Source array of height = nSrcHeight and width = nSrcWidth.
+ * @param pDst Destination transposed array of height = nSrcWidth and width = nSrcHeight.
+ * @param nSrcWidth Width of pSrc array.
+ * @param nSrcHeight Height of pSrc array.
+ */
+
+template <class DST, class SRC>
+void GDALTranspose2DSingleToSingle(const SRC *CPL_RESTRICT pSrc,
+                                   DST *CPL_RESTRICT pDst, size_t nSrcWidth,
+                                   size_t nSrcHeight)
+{
+    constexpr size_t blocksize = 32;
+    for (size_t i = 0; i < nSrcHeight; i += blocksize)
+    {
+        const size_t max_k = std::min(i + blocksize, nSrcHeight);
+        for (size_t j = 0; j < nSrcWidth; j += blocksize)
+        {
+            // transpose the block beginning at [i,j]
+            const size_t max_l = std::min(j + blocksize, nSrcWidth);
+            for (size_t k = i; k < max_k; ++k)
+            {
+                for (size_t l = j; l < max_l; ++l)
+                {
+                    GDALCopyWord(pSrc[l + k * nSrcWidth],
+                                 pDst[k + l * nSrcHeight]);
+                }
+            }
+        }
+    }
+}
+
+/************************************************************************/
+/*                   GDALTranspose2DComplexToComplex()                  */
+/************************************************************************/
+/**
+ * Transpose a 2D array of complex values into an array of complex values,
+ * in a efficient (cache-oblivious) way.
+ *
+ * @param pSrc Source array of height = nSrcHeight and width = nSrcWidth.
+ * @param pDst Destination transposed array of height = nSrcWidth and width = nSrcHeight.
+ * @param nSrcWidth Width of pSrc array.
+ * @param nSrcHeight Height of pSrc array.
+ */
+template <class DST, class SRC>
+void GDALTranspose2DComplexToComplex(const SRC *CPL_RESTRICT pSrc,
+                                     DST *CPL_RESTRICT pDst, size_t nSrcWidth,
+                                     size_t nSrcHeight)
+{
+    constexpr size_t blocksize = 32;
+    for (size_t i = 0; i < nSrcHeight; i += blocksize)
+    {
+        const size_t max_k = std::min(i + blocksize, nSrcHeight);
+        for (size_t j = 0; j < nSrcWidth; j += blocksize)
+        {
+            // transpose the block beginning at [i,j]
+            const size_t max_l = std::min(j + blocksize, nSrcWidth);
+            for (size_t k = i; k < max_k; ++k)
+            {
+                for (size_t l = j; l < max_l; ++l)
+                {
+                    GDALCopyWord(pSrc[2 * (l + k * nSrcWidth) + 0],
+                                 pDst[2 * (k + l * nSrcHeight) + 0]);
+                    GDALCopyWord(pSrc[2 * (l + k * nSrcWidth) + 1],
+                                 pDst[2 * (k + l * nSrcHeight) + 1]);
+                }
+            }
+        }
+    }
+}
+
+/************************************************************************/
+/*                   GDALTranspose2DComplexToSingle()                  */
+/************************************************************************/
+/**
+ * Transpose a 2D array of complex values into an array of non-complex values,
+ * in a efficient (cache-oblivious) way.
+ *
+ * @param pSrc Source array of height = nSrcHeight and width = nSrcWidth.
+ * @param pDst Destination transposed array of height = nSrcWidth and width = nSrcHeight.
+ * @param nSrcWidth Width of pSrc array.
+ * @param nSrcHeight Height of pSrc array.
+ */
+template <class DST, class SRC>
+void GDALTranspose2DComplexToSingle(const SRC *CPL_RESTRICT pSrc,
+                                    DST *CPL_RESTRICT pDst, size_t nSrcWidth,
+                                    size_t nSrcHeight)
+{
+    constexpr size_t blocksize = 32;
+    for (size_t i = 0; i < nSrcHeight; i += blocksize)
+    {
+        const size_t max_k = std::min(i + blocksize, nSrcHeight);
+        for (size_t j = 0; j < nSrcWidth; j += blocksize)
+        {
+            // transpose the block beginning at [i,j]
+            const size_t max_l = std::min(j + blocksize, nSrcWidth);
+            for (size_t k = i; k < max_k; ++k)
+            {
+                for (size_t l = j; l < max_l; ++l)
+                {
+                    GDALCopyWord(pSrc[2 * (l + k * nSrcWidth) + 0],
+                                 pDst[k + l * nSrcHeight]);
+                }
+            }
+        }
+    }
+}
+
+/************************************************************************/
+/*                   GDALTranspose2DSingleToComplex()                  */
+/************************************************************************/
+/**
+ * Transpose a 2D array of non-complex values into an array of complex values,
+ * in a efficient (cache-oblivious) way.
+ *
+ * @param pSrc Source array of height = nSrcHeight and width = nSrcWidth.
+ * @param pDst Destination transposed array of height = nSrcWidth and width = nSrcHeight.
+ * @param nSrcWidth Width of pSrc array.
+ * @param nSrcHeight Height of pSrc array.
+ */
+template <class DST, class SRC>
+void GDALTranspose2DSingleToComplex(const SRC *CPL_RESTRICT pSrc,
+                                    DST *CPL_RESTRICT pDst, size_t nSrcWidth,
+                                    size_t nSrcHeight)
+{
+    constexpr size_t blocksize = 32;
+    for (size_t i = 0; i < nSrcHeight; i += blocksize)
+    {
+        const size_t max_k = std::min(i + blocksize, nSrcHeight);
+        for (size_t j = 0; j < nSrcWidth; j += blocksize)
+        {
+            // transpose the block beginning at [i,j]
+            const size_t max_l = std::min(j + blocksize, nSrcWidth);
+            for (size_t k = i; k < max_k; ++k)
+            {
+                for (size_t l = j; l < max_l; ++l)
+                {
+                    GDALCopyWord(pSrc[l + k * nSrcWidth],
+                                 pDst[2 * (k + l * nSrcHeight) + 0]);
+                    pDst[2 * (k + l * nSrcHeight) + 1] = 0;
+                }
+            }
+        }
+    }
+}
+
 #endif  // GDAL_PRIV_TEMPLATES_HPP_INCLUDED
diff --git a/gcore/rasterio.cpp b/gcore/rasterio.cpp
index f95d2018c4de..716e6bfac4a1 100644
--- a/gcore/rasterio.cpp
+++ b/gcore/rasterio.cpp
@@ -5673,3 +5673,117 @@ void GDALDeinterleave(const void *pSourceBuffer, GDALDataType eSourceDT,
                         ppDestBuffer[iComp], eDestDT, nDestDTSize, nIters);
     }
 }
+
+/************************************************************************/
+/*                        GDALTranspose2D()                             */
+/************************************************************************/
+
+template <class DST, bool DST_IS_COMPLEX>
+static void GDALTranspose2D(const void *pSrc, GDALDataType eSrcType, DST *pDst,
+                            size_t nSrcWidth, size_t nSrcHeight)
+{
+#define GDALTranspose2D_internal(SRC_TYPE_CST, SRC_TYPE)                       \
+    case SRC_TYPE_CST:                                                         \
+        if constexpr (DST_IS_COMPLEX)                                          \
+        {                                                                      \
+            GDALTranspose2DSingleToComplex(                                    \
+                static_cast<const SRC_TYPE *>(pSrc), pDst, nSrcWidth,          \
+                nSrcHeight);                                                   \
+        }                                                                      \
+        else                                                                   \
+        {                                                                      \
+            GDALTranspose2DSingleToSingle(static_cast<const SRC_TYPE *>(pSrc), \
+                                          pDst, nSrcWidth, nSrcHeight);        \
+        }                                                                      \
+        break
+
+#define GDALTranspose2DComplex_internal(SRC_TYPE_CST, SRC_TYPE)                \
+    case SRC_TYPE_CST:                                                         \
+        if constexpr (DST_IS_COMPLEX)                                          \
+        {                                                                      \
+            GDALTranspose2DComplexToComplex(                                   \
+                static_cast<const SRC_TYPE *>(pSrc), pDst, nSrcWidth,          \
+                nSrcHeight);                                                   \
+        }                                                                      \
+        else                                                                   \
+        {                                                                      \
+            GDALTranspose2DComplexToSingle(                                    \
+                static_cast<const SRC_TYPE *>(pSrc), pDst, nSrcWidth,          \
+                nSrcHeight);                                                   \
+        }                                                                      \
+        break
+
+    switch (eSrcType)
+    {
+        GDALTranspose2D_internal(GDT_Byte, uint8_t);
+        GDALTranspose2D_internal(GDT_Int8, int8_t);
+        GDALTranspose2D_internal(GDT_UInt16, uint16_t);
+        GDALTranspose2D_internal(GDT_Int16, int16_t);
+        GDALTranspose2D_internal(GDT_UInt32, uint32_t);
+        GDALTranspose2D_internal(GDT_Int32, int32_t);
+        GDALTranspose2D_internal(GDT_UInt64, uint64_t);
+        GDALTranspose2D_internal(GDT_Int64, int64_t);
+        GDALTranspose2D_internal(GDT_Float32, float);
+        GDALTranspose2D_internal(GDT_Float64, double);
+        GDALTranspose2DComplex_internal(GDT_CInt16, int16_t);
+        GDALTranspose2DComplex_internal(GDT_CInt32, int32_t);
+        GDALTranspose2DComplex_internal(GDT_CFloat32, float);
+        GDALTranspose2DComplex_internal(GDT_CFloat64, double);
+        case GDT_Unknown:
+        case GDT_TypeCount:
+            break;
+    }
+
+#undef GDALTranspose2D_internal
+#undef GDALTranspose2DComplex_internal
+}
+
+/************************************************************************/
+/*                        GDALTranspose2D()                             */
+/************************************************************************/
+
+/**
+ * Transpose a 2D array in a efficient (cache-oblivious) way.
+ *
+ * @param pSrc Source array of width = nSrcWidth and height = nSrcHeight.
+ * @param eSrcType Data type of pSrc.
+ * @param pDst Destination transposed array of width = nSrcHeight and height = nSrcWidth.
+ * @param eDstType Data type of pDst.
+ * @param nSrcWidth Width of pSrc array.
+ * @param nSrcHeight Height of pSrc array.
+ * @since GDAL 3.11
+ */
+
+void GDALTranspose2D(const void *pSrc, GDALDataType eSrcType, void *pDst,
+                     GDALDataType eDstType, size_t nSrcWidth, size_t nSrcHeight)
+{
+#define GDALTranspose2D_internal(DST_TYPE_CST, DST_TYPE, DST_IS_COMPLEX)       \
+    case DST_TYPE_CST:                                                         \
+        GDALTranspose2D<DST_TYPE, DST_IS_COMPLEX>(                             \
+            pSrc, eSrcType, static_cast<DST_TYPE *>(pDst), nSrcWidth,          \
+            nSrcHeight);                                                       \
+        break
+
+    switch (eDstType)
+    {
+        GDALTranspose2D_internal(GDT_Byte, uint8_t, false);
+        GDALTranspose2D_internal(GDT_Int8, int8_t, false);
+        GDALTranspose2D_internal(GDT_UInt16, uint16_t, false);
+        GDALTranspose2D_internal(GDT_Int16, int16_t, false);
+        GDALTranspose2D_internal(GDT_UInt32, uint32_t, false);
+        GDALTranspose2D_internal(GDT_Int32, int32_t, false);
+        GDALTranspose2D_internal(GDT_UInt64, uint64_t, false);
+        GDALTranspose2D_internal(GDT_Int64, int64_t, false);
+        GDALTranspose2D_internal(GDT_Float32, float, false);
+        GDALTranspose2D_internal(GDT_Float64, double, false);
+        GDALTranspose2D_internal(GDT_CInt16, int16_t, true);
+        GDALTranspose2D_internal(GDT_CInt32, int32_t, true);
+        GDALTranspose2D_internal(GDT_CFloat32, float, true);
+        GDALTranspose2D_internal(GDT_CFloat64, double, true);
+        case GDT_Unknown:
+        case GDT_TypeCount:
+            break;
+    }
+
+#undef GDALTranspose2D_internal
+}

From 8d2962ffa6ecf18e6aa1e68e1027b67ed8775dcb Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Fri, 3 Jan 2025 18:25:15 +0100
Subject: [PATCH 22/40] multidim: use GDALTranspose2D()

---
 gcore/gdalmultidim.cpp | 63 +++---------------------------------------
 1 file changed, 4 insertions(+), 59 deletions(-)

diff --git a/gcore/gdalmultidim.cpp b/gcore/gdalmultidim.cpp
index b26384a35b91..d711474ce13f 100644
--- a/gcore/gdalmultidim.cpp
+++ b/gcore/gdalmultidim.cpp
@@ -4681,33 +4681,6 @@ static void CopyToFinalBuffer(const void *pSrcBuffer,
         goto lbl_return_to_caller_in_loop;
 }
 
-/************************************************************************/
-/*                          Transpose2D()                               */
-/************************************************************************/
-
-template <class T>
-static void Transpose2D(T *dst, const T *src, size_t src_height,
-                        size_t src_width)
-{
-    constexpr size_t blocksize = 32;
-    for (size_t i = 0; i < src_height; i += blocksize)
-    {
-        for (size_t j = 0; j < src_width; j += blocksize)
-        {
-            // transpose the block beginning at [i,j]
-            const size_t max_k = std::min(i + blocksize, src_height);
-            for (size_t k = i; k < max_k; ++k)
-            {
-                const size_t max_l = std::min(j + blocksize, src_width);
-                for (size_t l = j; l < max_l; ++l)
-                {
-                    dst[k + l * src_height] = src[l + k * src_width];
-                }
-            }
-        }
-    }
-}
-
 /************************************************************************/
 /*                      TransposeLast2Dims()                            */
 /************************************************************************/
@@ -4727,38 +4700,10 @@ static bool TransposeLast2Dims(void *pDstBuffer,
     GByte *pabyDstBuffer = static_cast<GByte *>(pDstBuffer);
     for (size_t i = 0; i < nEltsNonLast2Dims; ++i)
     {
-        if (nDTSize == 1)
-        {
-            Transpose2D(
-                static_cast<uint8_t *>(pTempBufferForLast2DimsTranspose),
-                reinterpret_cast<const uint8_t *>(pabyDstBuffer),
-                count[nDims - 2], count[nDims - 1]);
-        }
-        else if (nDTSize == 2)
-        {
-            Transpose2D(
-                static_cast<uint16_t *>(pTempBufferForLast2DimsTranspose),
-                reinterpret_cast<const uint16_t *>(pabyDstBuffer),
-                count[nDims - 2], count[nDims - 1]);
-        }
-        else if (nDTSize == 4)
-        {
-            Transpose2D(
-                static_cast<uint32_t *>(pTempBufferForLast2DimsTranspose),
-                reinterpret_cast<const uint32_t *>(pabyDstBuffer),
-                count[nDims - 2], count[nDims - 1]);
-        }
-        else if (nDTSize == 8)
-        {
-            Transpose2D(
-                static_cast<uint64_t *>(pTempBufferForLast2DimsTranspose),
-                reinterpret_cast<const uint64_t *>(pabyDstBuffer),
-                count[nDims - 2], count[nDims - 1]);
-        }
-        else
-        {
-            CPLAssert(false);
-        }
+        GDALTranspose2D(pabyDstBuffer, eDT.GetNumericDataType(),
+                        pTempBufferForLast2DimsTranspose,
+                        eDT.GetNumericDataType(), count[nDims - 1],
+                        count[nDims - 2]);
         memcpy(pabyDstBuffer, pTempBufferForLast2DimsTranspose,
                nDTSize * nEltsLast2Dims);
         pabyDstBuffer += nDTSize * nEltsLast2Dims;

From c692d8fc11fb3687a85d2481fef5964abc84d162 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Fri, 3 Jan 2025 18:25:33 +0100
Subject: [PATCH 23/40] VRTProcessedDataset: use GDALTranspose2D()

---
 autotest/gdrivers/vrtprocesseddataset.py |   7 +-
 frmts/vrt/vrtprocesseddataset.cpp        | 100 ++++++++++++++++++-----
 2 files changed, 83 insertions(+), 24 deletions(-)

diff --git a/autotest/gdrivers/vrtprocesseddataset.py b/autotest/gdrivers/vrtprocesseddataset.py
index fe076b8b8b08..e3ff9a1bf787 100755
--- a/autotest/gdrivers/vrtprocesseddataset.py
+++ b/autotest/gdrivers/vrtprocesseddataset.py
@@ -123,10 +123,13 @@ def test_vrtprocesseddataset_errors(tmp_vsimem):
 # Test nominal cases of BandAffineCombination algorithm
 
 
-def test_vrtprocesseddataset_affine_combination_nominal(tmp_vsimem):
+@pytest.mark.parametrize("INTERLEAVE", ["PIXEL", "BAND"])
+def test_vrtprocesseddataset_affine_combination_nominal(tmp_vsimem, INTERLEAVE):
 
     src_filename = str(tmp_vsimem / "src.tif")
-    src_ds = gdal.GetDriverByName("GTiff").Create(src_filename, 2, 1, 3)
+    src_ds = gdal.GetDriverByName("GTiff").Create(
+        src_filename, 2, 1, 3, options=["INTERLEAVE=" + INTERLEAVE]
+    )
     src_ds.GetRasterBand(1).WriteArray(np.array([[1, 3]]))
     src_ds.GetRasterBand(2).WriteArray(np.array([[2, 6]]))
     src_ds.GetRasterBand(3).WriteArray(np.array([[3, 3]]))
diff --git a/frmts/vrt/vrtprocesseddataset.cpp b/frmts/vrt/vrtprocesseddataset.cpp
index 27ee1a437f69..d8b0875618a4 100644
--- a/frmts/vrt/vrtprocesseddataset.cpp
+++ b/frmts/vrt/vrtprocesseddataset.cpp
@@ -1040,32 +1040,91 @@ bool VRTProcessedDataset::ProcessRegion(int nXOff, int nYOff, int nBufXSize,
 
     CPLAssert(!m_aoSteps.empty());
 
+    const size_t nPixelCount = static_cast<size_t>(nBufXSize) * nBufYSize;
+
     const int nFirstBandCount = m_aoSteps.front().nInBands;
     CPLAssert(nFirstBandCount == m_poSrcDS->GetRasterCount());
     const GDALDataType eFirstDT = m_aoSteps.front().eInDT;
     const int nFirstDTSize = GDALGetDataTypeSizeBytes(eFirstDT);
     auto &abyInput = m_abyInput;
     auto &abyOutput = m_abyOutput;
-    try
+
+    const char *pszInterleave =
+        m_poSrcDS->GetMetadataItem("INTERLEAVE", "IMAGE_STRUCTURE");
+    if (nFirstBandCount > 1 && (!pszInterleave || EQUAL(pszInterleave, "BAND")))
     {
-        abyInput.resize(static_cast<size_t>(nBufXSize) * nBufYSize *
-                        nFirstBandCount * nFirstDTSize);
+        // If there are several bands and the source dataset organization
+        // is apparently band interleaved, then first acquire data in
+        // a BSQ organization in the abyInput array use in the native
+        // data type.
+        // And then transpose it and convert it to the expected data type
+        // of the first step.
+        const auto eSrcDT = m_poSrcDS->GetRasterBand(1)->GetRasterDataType();
+        try
+        {
+            abyInput.resize(nPixelCount * nFirstBandCount *
+                            GDALGetDataTypeSizeBytes(eSrcDT));
+        }
+        catch (const std::bad_alloc &)
+        {
+            CPLError(CE_Failure, CPLE_OutOfMemory,
+                     "Out of memory allocating working buffer");
+            return false;
+        }
+
+        try
+        {
+            abyOutput.resize(nPixelCount * nFirstBandCount * nFirstDTSize);
+        }
+        catch (const std::bad_alloc &)
+        {
+            CPLError(CE_Failure, CPLE_OutOfMemory,
+                     "Out of memory allocating working buffer");
+            return false;
+        }
+
+        CPLDebugOnly("VRT", "ProcessRegion(): start RasterIO()");
+        if (m_poSrcDS->RasterIO(GF_Read, nXOff, nYOff, nBufXSize, nBufYSize,
+                                abyInput.data(), nBufXSize, nBufYSize, eSrcDT,
+                                nFirstBandCount, nullptr, 0, 0, 0,
+                                nullptr) != CE_None)
+        {
+            return false;
+        }
+        CPLDebugOnly("VRT", "ProcessRegion(): end RasterIO()");
+
+        CPLDebugOnly("VRT", "ProcessRegion(): start GDALTranspose2D()");
+        GDALTranspose2D(abyInput.data(), eSrcDT, abyOutput.data(), eFirstDT,
+                        static_cast<size_t>(nBufXSize) * nBufYSize,
+                        nFirstBandCount);
+        CPLDebugOnly("VRT", "ProcessRegion(): end GDALTranspose2D()");
+
+        // Swap arrays
+        std::swap(abyInput, abyOutput);
     }
-    catch (const std::bad_alloc &)
+    else
     {
-        CPLError(CE_Failure, CPLE_OutOfMemory,
-                 "Out of memory allocating working buffer");
-        return false;
-    }
+        try
+        {
+            abyInput.resize(nPixelCount * nFirstBandCount * nFirstDTSize);
+        }
+        catch (const std::bad_alloc &)
+        {
+            CPLError(CE_Failure, CPLE_OutOfMemory,
+                     "Out of memory allocating working buffer");
+            return false;
+        }
 
-    if (m_poSrcDS->RasterIO(
-            GF_Read, nXOff, nYOff, nBufXSize, nBufYSize, abyInput.data(),
-            nBufXSize, nBufYSize, eFirstDT, nFirstBandCount, nullptr,
-            static_cast<GSpacing>(nFirstDTSize) * nFirstBandCount,
-            static_cast<GSpacing>(nFirstDTSize) * nFirstBandCount * nBufXSize,
-            nFirstDTSize, nullptr) != CE_None)
-    {
-        return false;
+        if (m_poSrcDS->RasterIO(
+                GF_Read, nXOff, nYOff, nBufXSize, nBufYSize, abyInput.data(),
+                nBufXSize, nBufYSize, eFirstDT, nFirstBandCount, nullptr,
+                static_cast<GSpacing>(nFirstDTSize) * nFirstBandCount,
+                static_cast<GSpacing>(nFirstDTSize) * nFirstBandCount *
+                    nBufXSize,
+                nFirstDTSize, nullptr) != CE_None)
+        {
+            return false;
+        }
     }
 
     const double dfSrcXOff = nXOff;
@@ -1096,8 +1155,7 @@ bool VRTProcessedDataset::ProcessRegion(int nXOff, int nYOff, int nBufXSize,
         {
             try
             {
-                abyOutput.resize(static_cast<size_t>(nBufXSize) * nBufYSize *
-                                 oStep.nInBands *
+                abyOutput.resize(nPixelCount * oStep.nInBands *
                                  GDALGetDataTypeSizeBytes(oStep.eInDT));
             }
             catch (const std::bad_alloc &)
@@ -1110,16 +1168,14 @@ bool VRTProcessedDataset::ProcessRegion(int nXOff, int nYOff, int nBufXSize,
             GDALCopyWords64(abyInput.data(), eLastDT,
                             GDALGetDataTypeSizeBytes(eLastDT), abyOutput.data(),
                             oStep.eInDT, GDALGetDataTypeSizeBytes(oStep.eInDT),
-                            static_cast<size_t>(nBufXSize) * nBufYSize *
-                                oStep.nInBands);
+                            nPixelCount * oStep.nInBands);
 
             std::swap(abyInput, abyOutput);
         }
 
         try
         {
-            abyOutput.resize(static_cast<size_t>(nBufXSize) * nBufYSize *
-                             oStep.nOutBands *
+            abyOutput.resize(nPixelCount * oStep.nOutBands *
                              GDALGetDataTypeSizeBytes(oStep.eOutDT));
         }
         catch (const std::bad_alloc &)

From dc7345a634d1df1bc54faf211a63da9318b82df4 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Sun, 5 Jan 2025 00:49:23 +0100
Subject: [PATCH 24/40] Fix -Wnull-dereference warnings in -O2 -DDEBUG mode

---
 frmts/gti/gdaltileindexdataset.cpp |  1 +
 ogr/ogrsf_frmts/pg/ogrpglayer.cpp  | 13 ++++++++-----
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/frmts/gti/gdaltileindexdataset.cpp b/frmts/gti/gdaltileindexdataset.cpp
index 3877324665f8..2f4581c9ee55 100644
--- a/frmts/gti/gdaltileindexdataset.cpp
+++ b/frmts/gti/gdaltileindexdataset.cpp
@@ -4122,6 +4122,7 @@ void GDALTileIndexDataset::InitBuffer(void *pData, int nBufXSize, int nBufYSize,
             nBandNr == 0
                 ? m_poMaskBand.get()
                 : cpl::down_cast<GDALTileIndexBand *>(papoBands[nBandNr - 1]);
+        CPLAssert(poVRTBand);
         const double dfNoData = poVRTBand->m_dfNoDataValue;
         if (dfNoData == 0.0)
         {
diff --git a/ogr/ogrsf_frmts/pg/ogrpglayer.cpp b/ogr/ogrsf_frmts/pg/ogrpglayer.cpp
index 5e98b1113105..05f4685fd16d 100644
--- a/ogr/ogrsf_frmts/pg/ogrpglayer.cpp
+++ b/ogr/ogrsf_frmts/pg/ogrpglayer.cpp
@@ -1943,9 +1943,12 @@ OGRErr OGRPGLayer::GetExtent(int iGeomField, OGREnvelope *psExtent, int bForce)
 OGRErr OGRPGLayer::GetExtent3D(int iGeomField, OGREnvelope3D *psExtent3D,
                                int bForce)
 {
+    auto poLayerDefn = GetLayerDefn();
+
     // If the geometry field is not 3D go for 2D
-    if (GetLayerDefn()->GetGeomFieldCount() > iGeomField &&
-        !OGR_GT_HasZ(GetLayerDefn()->GetGeomFieldDefn(iGeomField)->GetType()))
+    if (poLayerDefn->GetGeomFieldCount() > iGeomField &&
+        !OGR_GT_HasZ(CPLAssertNotNull(poLayerDefn->GetGeomFieldDefn(iGeomField))
+                         ->GetType()))
     {
         const OGRErr retVal{GetExtent(iGeomField, psExtent3D, bForce)};
         psExtent3D->MinZ = std::numeric_limits<double>::infinity();
@@ -1955,8 +1958,8 @@ OGRErr OGRPGLayer::GetExtent3D(int iGeomField, OGREnvelope3D *psExtent3D,
 
     CPLString osCommand;
 
-    if (iGeomField < 0 || iGeomField >= GetLayerDefn()->GetGeomFieldCount() ||
-        CPLAssertNotNull(GetLayerDefn()->GetGeomFieldDefn(iGeomField))
+    if (iGeomField < 0 || iGeomField >= poLayerDefn->GetGeomFieldCount() ||
+        CPLAssertNotNull(poLayerDefn->GetGeomFieldDefn(iGeomField))
                 ->GetType() == wkbNone)
     {
         if (iGeomField != 0)
@@ -1968,7 +1971,7 @@ OGRErr OGRPGLayer::GetExtent3D(int iGeomField, OGREnvelope3D *psExtent3D,
     }
 
     OGRPGGeomFieldDefn *poGeomFieldDefn =
-        poFeatureDefn->GetGeomFieldDefn(iGeomField);
+        poLayerDefn->GetGeomFieldDefn(iGeomField);
 
     if (TestCapability(OLCFastGetExtent3D))
     {

From d5de2e51f57e2c96eda49e56e28ffc48b3bb9eda Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Sun, 5 Jan 2025 02:27:44 +0100
Subject: [PATCH 25/40] GDALTranspose2D(): add SSSE3 optimizations

---
 autotest/cpp/test_gdal.cpp      |  93 ++++++++
 gcore/rasterio.cpp              |  83 +++++++
 gcore/rasterio_ssse3.cpp        | 398 +++++++++++++++++++++++++++++++-
 gcore/rasterio_ssse3.h          |   4 +
 perftests/CMakeLists.txt        |   7 +
 perftests/testperftranspose.cpp |  97 ++++++++
 6 files changed, 674 insertions(+), 8 deletions(-)
 create mode 100644 perftests/testperftranspose.cpp

diff --git a/autotest/cpp/test_gdal.cpp b/autotest/cpp/test_gdal.cpp
index 5b3289cf66ce..0a5a160c521a 100644
--- a/autotest/cpp/test_gdal.cpp
+++ b/autotest/cpp/test_gdal.cpp
@@ -4989,4 +4989,97 @@ TEST_F(test_gdal, GDALTranspose2D)
     }
 }
 
+TEST_F(test_gdal, GDALTranspose2D_Byte_optims)
+{
+    std::vector<GByte> in;
+    for (int i = 0; i < 19 * 17; ++i)
+        in.push_back(static_cast<GByte>(i % 256));
+
+    std::vector<GByte> out(in.size());
+
+    // SSSE3 optim (16x16) blocks
+    {
+        constexpr int W = 19;
+        constexpr int H = 17;
+        GDALTranspose2D(in.data(), GDT_Byte, out.data(), GDT_Byte, W, H);
+        for (int y = 0; y < H; ++y)
+        {
+            for (int x = 0; x < W; ++x)
+            {
+                EXPECT_EQ(out[x * H + y], in[y * W + x]);
+            }
+        }
+    }
+
+    // Optim H = 2
+    {
+        constexpr int W = 19;
+        constexpr int H = 2;
+        GDALTranspose2D(in.data(), GDT_Byte, out.data(), GDT_Byte, W, H);
+        for (int y = 0; y < H; ++y)
+        {
+            for (int x = 0; x < W; ++x)
+            {
+                EXPECT_EQ(out[x * H + y], in[y * W + x]);
+            }
+        }
+    }
+
+    // SSSE3 optim H = 3
+    {
+        constexpr int W = 19;
+        constexpr int H = 3;
+        GDALTranspose2D(in.data(), GDT_Byte, out.data(), GDT_Byte, W, H);
+        for (int y = 0; y < H; ++y)
+        {
+            for (int x = 0; x < W; ++x)
+            {
+                EXPECT_EQ(out[x * H + y], in[y * W + x]);
+            }
+        }
+    }
+
+    // Optim H = 4
+    {
+        constexpr int W = 19;
+        constexpr int H = 4;
+        GDALTranspose2D(in.data(), GDT_Byte, out.data(), GDT_Byte, W, H);
+        for (int y = 0; y < H; ++y)
+        {
+            for (int x = 0; x < W; ++x)
+            {
+                EXPECT_EQ(out[x * H + y], in[y * W + x]);
+            }
+        }
+    }
+
+    // SSSE3 optim H = 5 with W < 16
+    {
+        constexpr int W = 15;
+        constexpr int H = 5;
+        GDALTranspose2D(in.data(), GDT_Byte, out.data(), GDT_Byte, W, H);
+        for (int y = 0; y < H; ++y)
+        {
+            for (int x = 0; x < W; ++x)
+            {
+                EXPECT_EQ(out[x * H + y], in[y * W + x]);
+            }
+        }
+    }
+
+    // SSSE3 optim H = 5 with W >= 16
+    {
+        constexpr int W = 19;
+        constexpr int H = 5;
+        GDALTranspose2D(in.data(), GDT_Byte, out.data(), GDT_Byte, W, H);
+        for (int y = 0; y < H; ++y)
+        {
+            for (int x = 0; x < W; ++x)
+            {
+                EXPECT_EQ(out[x * H + y], in[y * W + x]);
+            }
+        }
+    }
+}
+
 }  // namespace
diff --git a/gcore/rasterio.cpp b/gcore/rasterio.cpp
index 716e6bfac4a1..d4949efbf47e 100644
--- a/gcore/rasterio.cpp
+++ b/gcore/rasterio.cpp
@@ -5738,6 +5738,56 @@ static void GDALTranspose2D(const void *pSrc, GDALDataType eSrcType, DST *pDst,
 #undef GDALTranspose2DComplex_internal
 }
 
+/************************************************************************/
+/*                      GDALInterleave2Byte()                           */
+/************************************************************************/
+
+#if defined(__GNUC__) && !defined(__clang__)
+__attribute__((optimize("tree-vectorize")))
+#endif
+#if defined(__GNUC__)
+__attribute__((noinline))
+#endif
+static void
+GDALInterleave2Byte(const uint8_t *CPL_RESTRICT pSrc,
+                    uint8_t *CPL_RESTRICT pDst, size_t nIters)
+{
+#if defined(__clang__)
+#pragma clang loop vectorize(enable)
+#endif
+    for (size_t i = 0; i < nIters; ++i)
+    {
+        pDst[2 * i + 0] = pSrc[i + 0 * nIters];
+        pDst[2 * i + 1] = pSrc[i + 1 * nIters];
+    }
+}
+
+/************************************************************************/
+/*                      GDALInterleave4Byte()                           */
+/************************************************************************/
+
+#if defined(__GNUC__) && !defined(__clang__)
+__attribute__((optimize("tree-vectorize")))
+#endif
+#if defined(__GNUC__)
+__attribute__((noinline))
+#endif
+static void
+GDALInterleave4Byte(const uint8_t *CPL_RESTRICT pSrc,
+                    uint8_t *CPL_RESTRICT pDst, size_t nIters)
+{
+#if defined(__clang__)
+#pragma clang loop vectorize(enable)
+#endif
+    for (size_t i = 0; i < nIters; ++i)
+    {
+        pDst[4 * i + 0] = pSrc[i + 0 * nIters];
+        pDst[4 * i + 1] = pSrc[i + 1 * nIters];
+        pDst[4 * i + 2] = pSrc[i + 2 * nIters];
+        pDst[4 * i + 3] = pSrc[i + 3 * nIters];
+    }
+}
+
 /************************************************************************/
 /*                        GDALTranspose2D()                             */
 /************************************************************************/
@@ -5757,6 +5807,39 @@ static void GDALTranspose2D(const void *pSrc, GDALDataType eSrcType, DST *pDst,
 void GDALTranspose2D(const void *pSrc, GDALDataType eSrcType, void *pDst,
                      GDALDataType eDstType, size_t nSrcWidth, size_t nSrcHeight)
 {
+    if (eSrcType == eDstType && (eSrcType == GDT_Byte || eSrcType == GDT_Int8))
+    {
+        if (nSrcHeight == 2)
+        {
+            GDALInterleave2Byte(static_cast<const uint8_t *>(pSrc),
+                                static_cast<uint8_t *>(pDst), nSrcWidth);
+            return;
+        }
+        if (nSrcHeight == 4)
+        {
+            GDALInterleave4Byte(static_cast<const uint8_t *>(pSrc),
+                                static_cast<uint8_t *>(pDst), nSrcWidth);
+            return;
+        }
+#if (defined(HAVE_SSSE3_AT_COMPILE_TIME) &&                                    \
+     (defined(__x86_64) || defined(_M_X64)))
+        if (CPLHaveRuntimeSSSE3())
+        {
+            GDALTranspose2D_Byte_SSSE3(static_cast<const uint8_t *>(pSrc),
+                                       static_cast<uint8_t *>(pDst), nSrcWidth,
+                                       nSrcHeight);
+            return;
+        }
+#elif defined(USE_NEON_OPTIMIZATIONS)
+        {
+            GDALTranspose2D_Byte_SSSE3(static_cast<const uint8_t *>(pSrc),
+                                       static_cast<uint8_t *>(pDst), nSrcWidth,
+                                       nSrcHeight);
+            return;
+        }
+#endif
+    }
+
 #define GDALTranspose2D_internal(DST_TYPE_CST, DST_TYPE, DST_IS_COMPLEX)       \
     case DST_TYPE_CST:                                                         \
         GDALTranspose2D<DST_TYPE, DST_IS_COMPLEX>(                             \
diff --git a/gcore/rasterio_ssse3.cpp b/gcore/rasterio_ssse3.cpp
index fa9cd6ab24e4..e3f9636a7c27 100644
--- a/gcore/rasterio_ssse3.cpp
+++ b/gcore/rasterio_ssse3.cpp
@@ -12,6 +12,8 @@
 
 #include "cpl_port.h"
 
+#include <algorithm>
+
 #if (defined(HAVE_SSSE3_AT_COMPILE_TIME) &&                                    \
      (defined(__x86_64) || defined(_M_X64))) ||                                \
     defined(USE_NEON_OPTIMIZATIONS)
@@ -140,6 +142,35 @@ void GDALDeinterleave3Byte_SSSE3(const GByte *CPL_RESTRICT pabySrc,
 }
 #endif
 
+/************************************************************************/
+/*                     GDALTranspose4x4Int32()                          */
+/************************************************************************/
+
+// Consider that the input registers for 4x4 words of size 4 bytes each,
+// Return the transposition of this 4x4 matrix
+// Considering that in0 = (in00, in01, in02, in03)
+// Considering that in1 = (in10, in11, in12, in13)
+// Considering that in2 = (in20, in21, in22, in23)
+// Considering that in3 = (in30, in31, in32, in33)
+// Return          out0 = (in00, in10, in20, in30)
+// Return          out1 = (in01, in11, in21, in31)
+// Return          out2 = (in02, in12, in22, in32)
+// Return          out3 = (in03, in13, in23, in33)
+inline void GDALTranspose4x4Int32(__m128i in0, __m128i in1, __m128i in2,
+                                  __m128i in3, __m128i &out0, __m128i &out1,
+                                  __m128i &out2, __m128i &out3)
+{
+    __m128i tmp0 = _mm_unpacklo_epi32(in0, in1);  // (in00, in10, in01, in11)
+    __m128i tmp1 = _mm_unpackhi_epi32(in0, in1);  // (in02, in12, in03, in13)
+    __m128i tmp2 = _mm_unpacklo_epi32(in2, in3);  // (in20, in30, in21, in31)
+    __m128i tmp3 = _mm_unpackhi_epi32(in2, in3);  // (in22, in32, in23, in33)
+
+    out0 = _mm_unpacklo_epi64(tmp0, tmp2);  // (in00, in10, in20, in30)
+    out1 = _mm_unpackhi_epi64(tmp0, tmp2);  // (in01, in11, in21, in31)
+    out2 = _mm_unpacklo_epi64(tmp1, tmp3);  // (in02, in12, in22, in32)
+    out3 = _mm_unpackhi_epi64(tmp1, tmp3);  // (in03, in13, in23, in33)
+}
+
 /************************************************************************/
 /*                  GDALDeinterleave4Byte_SSSE3()                       */
 /************************************************************************/
@@ -169,14 +200,7 @@ void GDALDeinterleave4Byte_SSSE3(const GByte *CPL_RESTRICT pabySrc,
         xmm2 = _mm_shuffle_epi8(xmm2, shuffle_mask);  // W8 W9 WA WB
         xmm3 = _mm_shuffle_epi8(xmm3, shuffle_mask);  // WC WD WE WF
 
-        __m128i xmm01lo = _mm_unpacklo_epi32(xmm0, xmm1);  // W0 W4 W1 W5
-        __m128i xmm01hi = _mm_unpackhi_epi32(xmm0, xmm1);  // W2 W6 W3 W7
-        __m128i xmm23lo = _mm_unpacklo_epi32(xmm2, xmm3);  // W8 WC W9 WD
-        __m128i xmm23hi = _mm_unpackhi_epi32(xmm2, xmm3);  // WA WE WB WF
-        xmm0 = _mm_unpacklo_epi64(xmm01lo, xmm23lo);       // W0 W4 W8 WC
-        xmm1 = _mm_unpackhi_epi64(xmm01lo, xmm23lo);       // W1 W5 W9 WD
-        xmm2 = _mm_unpacklo_epi64(xmm01hi, xmm23hi);       // W2 W6 WA WE
-        xmm3 = _mm_unpackhi_epi64(xmm01hi, xmm23hi);       // W3 W7 WB WF
+        GDALTranspose4x4Int32(xmm0, xmm1, xmm2, xmm3, xmm0, xmm1, xmm2, xmm3);
 
         _mm_storeu_si128(reinterpret_cast<__m128i *>(pabyDest0 + i), xmm0);
         _mm_storeu_si128(reinterpret_cast<__m128i *>(pabyDest1 + i), xmm1);
@@ -248,4 +272,362 @@ void GDALDeinterleave4UInt16_SSSE3(const GUInt16* CPL_RESTRICT panSrc,
 }
 #endif
 
+/************************************************************************/
+/*                      GDALInterleave3Byte_SSSE3()                     */
+/************************************************************************/
+
+#if defined(__GNUC__) && !defined(__clang__)
+__attribute__((optimize("tree-vectorize")))
+#endif
+#if defined(__GNUC__)
+__attribute__((noinline))
+#endif
+static void
+GDALInterleave3Byte_SSSE3(const uint8_t *CPL_RESTRICT pSrc,
+                          uint8_t *CPL_RESTRICT pDst, size_t nIters)
+{
+#if defined(__clang__)
+#pragma clang loop vectorize(enable)
+#endif
+    for (size_t i = 0; i < nIters; ++i)
+    {
+        pDst[3 * i + 0] = pSrc[i + 0 * nIters];
+        pDst[3 * i + 1] = pSrc[i + 1 * nIters];
+        pDst[3 * i + 2] = pSrc[i + 2 * nIters];
+    }
+}
+
+/************************************************************************/
+/*                      GDALInterleave5Byte_SSSE3()                     */
+/************************************************************************/
+
+inline __m128i loadu(const uint8_t *pSrc, size_t i, size_t srcStride)
+{
+    return _mm_loadu_si128(
+        reinterpret_cast<const __m128i *>(pSrc + i * srcStride));
+}
+
+inline void storeu(uint8_t *pDst, size_t i, size_t dstStride, __m128i reg)
+{
+    _mm_storeu_si128(reinterpret_cast<__m128i *>(pDst + i * dstStride), reg);
+}
+
+inline __m128i GDAL_mm_or_5_si128(__m128i r0, __m128i r1, __m128i r2,
+                                  __m128i r3, __m128i r4)
+{
+    return _mm_or_si128(
+        _mm_or_si128(_mm_or_si128(r0, r1), _mm_or_si128(r2, r3)), r4);
+}
+
+void GDALInterleave5Byte_SSSE3(const uint8_t *CPL_RESTRICT pSrc,
+                               uint8_t *CPL_RESTRICT pDst, size_t nIters)
+{
+    size_t i = 0;
+    constexpr size_t VALS_PER_ITER = 16;
+
+    if (nIters >= VALS_PER_ITER)
+    {
+        // clang-format off
+        constexpr char X = -1;
+        // How to dispatch 16 values of row=0 onto 5x16 bytes
+        const __m128i xmm_shuffle00 = _mm_setr_epi8(0, X, X, X, X,
+                                                    1, X, X, X, X,
+                                                    2, X, X, X, X,
+                                                    3);
+        const __m128i xmm_shuffle01 = _mm_setr_epi8(   X, X, X, X,
+                                                    4, X, X, X, X,
+                                                    5, X, X, X, X,
+                                                    6, X);
+        const __m128i xmm_shuffle02 = _mm_setr_epi8(      X, X, X,
+                                                    7, X, X, X, X,
+                                                    8, X, X, X, X,
+                                                    9, X, X);
+        const __m128i xmm_shuffle03 = _mm_setr_epi8(          X, X,
+                                                    10, X, X, X, X,
+                                                    11, X, X, X, X,
+                                                    12, X, X, X);
+        const __m128i xmm_shuffle04 = _mm_setr_epi8(             X,
+                                                    13, X, X, X, X,
+                                                    14, X, X, X, X,
+                                                    15, X, X, X, X);
+
+        // How to dispatch 16 values of row=1 onto 5x16 bytes
+        const __m128i xmm_shuffle10 = _mm_setr_epi8(X, 0, X, X, X,
+                                                    X, 1, X, X, X,
+                                                    X, 2, X, X, X,
+                                                    X);
+        const __m128i xmm_shuffle11 = _mm_setr_epi8(   3, X, X, X,
+                                                    X, 4, X, X, X,
+                                                    X, 5, X, X, X,
+                                                    X, 6);
+        const __m128i xmm_shuffle12 = _mm_setr_epi8(      X, X, X,
+                                                    X, 7, X, X, X,
+                                                    X, 8, X, X, X,
+                                                    X, 9, X);
+        const __m128i xmm_shuffle13 = _mm_setr_epi8(          X, X,
+                                                    X, 10, X, X, X,
+                                                    X, 11, X, X, X,
+                                                    X, 12, X, X);
+        const __m128i xmm_shuffle14 = _mm_setr_epi8(             X,
+                                                    X, 13, X, X, X,
+                                                    X, 14, X, X, X,
+                                                    X, 15, X, X, X);
+
+        // How to dispatch 16 values of row=2 onto 5x16 bytes
+        const __m128i xmm_shuffle20 = _mm_setr_epi8(X, X, 0, X, X,
+                                                    X, X, 1, X, X,
+                                                    X, X, 2, X, X,
+                                                    X);
+        const __m128i xmm_shuffle21 = _mm_setr_epi8(   X, 3, X, X,
+                                                    X, X, 4, X, X,
+                                                    X, X, 5, X, X,
+                                                    X, X);
+        const __m128i xmm_shuffle22 = _mm_setr_epi8(      6, X, X,
+                                                    X, X, 7, X, X,
+                                                    X, X, 8, X, X,
+                                                    X, X, 9);
+        const __m128i xmm_shuffle23 = _mm_setr_epi8(          X, X,
+                                                    X, X, 10, X, X,
+                                                    X, X, 11, X, X,
+                                                    X, X, 12, X);
+        const __m128i xmm_shuffle24 = _mm_setr_epi8(             X,
+                                                    X, X, 13, X, X,
+                                                    X, X, 14, X, X,
+                                                    X, X, 15, X, X);
+
+        // How to dispatch 16 values of row=3 onto 5x16 bytes
+        const __m128i xmm_shuffle30 = _mm_setr_epi8(X, X, X, 0, X,
+                                                    X, X, X, 1, X,
+                                                    X, X, X, 2, X,
+                                                    X);
+        const __m128i xmm_shuffle31 = _mm_setr_epi8(   X, X, 3, X,
+                                                    X, X, X, 4, X,
+                                                    X, X, X, 5, X,
+                                                    X, X);
+        const __m128i xmm_shuffle32 = _mm_setr_epi8(      X, 6, X,
+                                                    X, X, X, 7, X,
+                                                    X, X, X, 8, X,
+                                                    X, X, X);
+        const __m128i xmm_shuffle33 = _mm_setr_epi8(          9, X,
+                                                    X, X, X, 10, X,
+                                                    X, X, X, 11, X,
+                                                    X, X, X, 12);
+        const __m128i xmm_shuffle34 = _mm_setr_epi8(             X,
+                                                    X, X, X, 13, X,
+                                                    X, X, X, 14, X,
+                                                    X, X, X, 15, X);
+
+        // How to dispatch 16 values of row=4 onto 5x16 bytes
+        const __m128i xmm_shuffle40 = _mm_setr_epi8(X, X, X, X, 0,
+                                                    X, X, X, X, 1,
+                                                    X, X, X, X, 2,
+                                                    X);
+        const __m128i xmm_shuffle41 = _mm_setr_epi8(   X, X, X, 3,
+                                                    X, X, X, X, 4,
+                                                    X, X, X, X, 5,
+                                                    X, X);
+        const __m128i xmm_shuffle42 = _mm_setr_epi8(      X, X, 6,
+                                                    X, X, X, X, 7,
+                                                    X, X, X, X, 8,
+                                                    X, X, X);
+        const __m128i xmm_shuffle43 = _mm_setr_epi8(         X,  9,
+                                                    X, X, X, X, 10,
+                                                    X, X, X, X, 11,
+                                                    X, X, X, X);
+        const __m128i xmm_shuffle44 = _mm_setr_epi8(            12,
+                                                    X, X, X, X, 13,
+                                                    X, X, X, X, 14,
+                                                    X, X, X, X, 15);
+        // clang-format on
+
+        for (; i + VALS_PER_ITER <= nIters; i += VALS_PER_ITER)
+        {
+#define LOAD(x) __m128i xmm##x = loadu(pSrc + i, x, nIters)
+            LOAD(0);
+            LOAD(1);
+            LOAD(2);
+            LOAD(3);
+            LOAD(4);
+
+#define SHUFFLE(x, y) _mm_shuffle_epi8(xmm##y, xmm_shuffle##y##x)
+#define COMBINE_5(x)                                                           \
+    GDAL_mm_or_5_si128(SHUFFLE(x, 0), SHUFFLE(x, 1), SHUFFLE(x, 2),            \
+                       SHUFFLE(x, 3), SHUFFLE(x, 4))
+
+#define STORE(x)                                                               \
+    storeu(pDst, 5 * (i / VALS_PER_ITER) + x, VALS_PER_ITER, COMBINE_5(x))
+            STORE(0);
+            STORE(1);
+            STORE(2);
+            STORE(3);
+            STORE(4);
+#undef LOAD
+#undef COMBINE_5
+#undef SHUFFLE
+#undef STORE
+        }
+    }
+
+    for (; i < nIters; ++i)
+    {
+#define INTERLEAVE(x) pDst[5 * i + x] = pSrc[i + x * nIters]
+        INTERLEAVE(0);
+        INTERLEAVE(1);
+        INTERLEAVE(2);
+        INTERLEAVE(3);
+        INTERLEAVE(4);
+#undef INTERLEAVE
+    }
+}
+
+/************************************************************************/
+/*                      GDALTranspose2D_Byte_SSSE3()                    */
+/************************************************************************/
+
+// Given r = (b00, b01, b02, b03,
+//            b10, b11, b12, b13,
+//            b20, b21, b22, b23,
+//            b30, b31, b32, b33)
+// Return    (b00, b10, b20, b30,
+//            b01, b11, b21, b31,
+//            b02, b12, b22, b32,
+//            b03, b13, b22, b33)
+inline void GDALReorderForTranspose4x4(__m128i &r)
+{
+    const __m128i shuffle_mask =
+        _mm_set_epi8(15, 11, 7, 3, 14, 10, 6, 2, 13, 9, 5, 1, 12, 8, 4, 0);
+
+    r = _mm_shuffle_epi8(r, shuffle_mask);
+}
+
+// Transpose the 16x16 byte values contained in the 16 SSE registers
+inline void GDALTranspose16x16ByteBlock_SSSE3(
+    __m128i &r00, __m128i &r01, __m128i &r02, __m128i &r03, __m128i &r04,
+    __m128i &r05, __m128i &r06, __m128i &r07, __m128i &r08, __m128i &r09,
+    __m128i &r10, __m128i &r11, __m128i &r12, __m128i &r13, __m128i &r14,
+    __m128i &r15)
+{
+    __m128i tmp00, tmp01, tmp02, tmp03;
+    __m128i tmp10, tmp11, tmp12, tmp13;
+    __m128i tmp20, tmp21, tmp22, tmp23;
+    __m128i tmp30, tmp31, tmp32, tmp33;
+
+    GDALTranspose4x4Int32(r00, r01, r02, r03, tmp00, tmp01, tmp02, tmp03);
+    GDALTranspose4x4Int32(r04, r05, r06, r07, tmp10, tmp11, tmp12, tmp13);
+    GDALTranspose4x4Int32(r08, r09, r10, r11, tmp20, tmp21, tmp22, tmp23);
+    GDALTranspose4x4Int32(r12, r13, r14, r15, tmp30, tmp31, tmp32, tmp33);
+
+    GDALReorderForTranspose4x4(tmp00);
+    GDALReorderForTranspose4x4(tmp01);
+    GDALReorderForTranspose4x4(tmp02);
+    GDALReorderForTranspose4x4(tmp03);
+    GDALReorderForTranspose4x4(tmp10);
+    GDALReorderForTranspose4x4(tmp11);
+    GDALReorderForTranspose4x4(tmp12);
+    GDALReorderForTranspose4x4(tmp13);
+    GDALReorderForTranspose4x4(tmp20);
+    GDALReorderForTranspose4x4(tmp21);
+    GDALReorderForTranspose4x4(tmp22);
+    GDALReorderForTranspose4x4(tmp23);
+    GDALReorderForTranspose4x4(tmp30);
+    GDALReorderForTranspose4x4(tmp31);
+    GDALReorderForTranspose4x4(tmp32);
+    GDALReorderForTranspose4x4(tmp33);
+
+    GDALTranspose4x4Int32(tmp00, tmp10, tmp20, tmp30, r00, r01, r02, r03);
+    GDALTranspose4x4Int32(tmp01, tmp11, tmp21, tmp31, r04, r05, r06, r07);
+    GDALTranspose4x4Int32(tmp02, tmp12, tmp22, tmp32, r08, r09, r10, r11);
+    GDALTranspose4x4Int32(tmp03, tmp13, tmp23, tmp33, r12, r13, r14, r15);
+}
+
+inline void GDALTranspose2D16x16Byte_SSSE3(const uint8_t *CPL_RESTRICT pSrc,
+                                           uint8_t *CPL_RESTRICT pDst,
+                                           size_t srcStride, size_t dstStride)
+{
+#define LOAD(x) __m128i r##x = loadu(pSrc, x, srcStride)
+    LOAD(0);
+    LOAD(1);
+    LOAD(2);
+    LOAD(3);
+    LOAD(4);
+    LOAD(5);
+    LOAD(6);
+    LOAD(7);
+    LOAD(8);
+    LOAD(9);
+    LOAD(10);
+    LOAD(11);
+    LOAD(12);
+    LOAD(13);
+    LOAD(14);
+    LOAD(15);
+#undef LOAD
+
+    GDALTranspose16x16ByteBlock_SSSE3(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9,
+                                      r10, r11, r12, r13, r14, r15);
+
+#define STORE(x) storeu(pDst, x, dstStride, r##x)
+    STORE(0);
+    STORE(1);
+    STORE(2);
+    STORE(3);
+    STORE(4);
+    STORE(5);
+    STORE(6);
+    STORE(7);
+    STORE(8);
+    STORE(9);
+    STORE(10);
+    STORE(11);
+    STORE(12);
+    STORE(13);
+    STORE(14);
+    STORE(15);
+#undef STORE
+}
+
+void GDALTranspose2D_Byte_SSSE3(const uint8_t *CPL_RESTRICT pSrc,
+                                uint8_t *CPL_RESTRICT pDst, size_t nSrcWidth,
+                                size_t nSrcHeight)
+{
+    if (nSrcHeight == 3)
+    {
+        GDALInterleave3Byte_SSSE3(pSrc, pDst, nSrcWidth);
+    }
+    else if (nSrcHeight == 5)
+    {
+        GDALInterleave5Byte_SSSE3(pSrc, pDst, nSrcWidth);
+    }
+    else
+    {
+        constexpr size_t blocksize = 16;
+        for (size_t i = 0; i < nSrcHeight; i += blocksize)
+        {
+            const size_t max_k = std::min(i + blocksize, nSrcHeight);
+            for (size_t j = 0; j < nSrcWidth; j += blocksize)
+            {
+                // transpose the block beginning at [i,j]
+                const size_t max_l = std::min(j + blocksize, nSrcWidth);
+                if (max_k - i == blocksize && max_l - j == blocksize)
+                {
+                    GDALTranspose2D16x16Byte_SSSE3(&pSrc[j + i * nSrcWidth],
+                                                   &pDst[i + j * nSrcHeight],
+                                                   nSrcWidth, nSrcHeight);
+                }
+                else
+                {
+                    for (size_t k = i; k < max_k; ++k)
+                    {
+                        for (size_t l = j; l < max_l; ++l)
+                        {
+                            GDALCopyWord(pSrc[l + k * nSrcWidth],
+                                         pDst[k + l * nSrcHeight]);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
 #endif  // HAVE_SSSE3_AT_COMPILE_TIME
diff --git a/gcore/rasterio_ssse3.h b/gcore/rasterio_ssse3.h
index ac20e45c6c57..f720201842ac 100644
--- a/gcore/rasterio_ssse3.h
+++ b/gcore/rasterio_ssse3.h
@@ -54,6 +54,10 @@ void GDALDeinterleave4UInt16_SSSE3(const GUInt16 *CPL_RESTRICT panSrc,
                                    size_t nIters);
 #endif
 
+void GDALTranspose2D_Byte_SSSE3(const uint8_t *CPL_RESTRICT pSrc,
+                                uint8_t *CPL_RESTRICT pDst, size_t nSrcWidth,
+                                size_t nSrcHeight);
+
 #endif
 
 #endif /* RASTERIO_SSSE3_H_INCLUDED */
diff --git a/perftests/CMakeLists.txt b/perftests/CMakeLists.txt
index a103013d3c9b..15efe1c6568f 100644
--- a/perftests/CMakeLists.txt
+++ b/perftests/CMakeLists.txt
@@ -30,3 +30,10 @@ if (GDAL_ENABLE_ARM_NEON_OPTIMIZATIONS)
 endif()
 add_test(NAME testperf_gdal_minmax_element COMMAND testperf_gdal_minmax_element)
 set_property(TEST testperf_gdal_minmax_element PROPERTY ENVIRONMENT "${TEST_ENV}")
+
+gdal_test_target(testperftranspose testperftranspose.cpp)
+if (HAVE_SSSE3_AT_COMPILE_TIME)
+  target_compile_definitions(testperftranspose PRIVATE -DHAVE_SSSE3_AT_COMPILE_TIME)
+endif()
+add_test(NAME testperftranspose COMMAND testperftranspose)
+set_property(TEST testperftranspose PROPERTY ENVIRONMENT "${TEST_ENV}")
diff --git a/perftests/testperftranspose.cpp b/perftests/testperftranspose.cpp
new file mode 100644
index 000000000000..1da1944e6808
--- /dev/null
+++ b/perftests/testperftranspose.cpp
@@ -0,0 +1,97 @@
+/******************************************************************************
+ * $Id$
+ *
+ * Project:  GDAL Core
+ * Purpose:  Test performance of GDADLTranspose2D().
+ * Author:   Even Rouault, <even dot rouault at spatialys.com>
+ *
+ ******************************************************************************
+ * Copyright (c) 2025, Even Rouault <even dot rouault at spatialys.com>
+ *
+ * SPDX-License-Identifier: MIT
+ ****************************************************************************/
+
+#include "gdal.h"
+#include "cpl_conv.h"
+
+#include <cstdio>
+#include <cstdlib>
+#include <ctime>
+
+#define SIZE (1024 * 1024 + 1) * 100
+
+static void test(const void *pSrc, GDALDataType eSrcType, void *pDst,
+                 GDALDataType eDstType, int W, int H, int reducFactor,
+                 const char *extraMsg = "")
+{
+    CPLAssert(W * H <= SIZE);
+
+    const int niters =
+        static_cast<int>(4000U * 1000 * 1000 / reducFactor / W / H);
+    const auto start = clock();
+    for (int i = 0; i < niters; ++i)
+        GDALTranspose2D(pSrc, eSrcType, pDst, eDstType, W, H);
+    const auto end = clock();
+    printf("W=%d, H=%d, reducFactor=%d%s: %0.2f sec\n", W, H, reducFactor,
+           extraMsg, (end - start) * reducFactor * 1.0 / CLOCKS_PER_SEC);
+}
+
+int main(int /* argc */, char * /* argv */[])
+{
+    if (strstr(GDALVersionInfo("--version"), "debug build"))
+    {
+        printf("Skipping testperftranspose as this a debug build!\n");
+        return 0;
+    }
+
+    void *src = CPLCalloc(1, SIZE);
+    void *dst = CPLCalloc(1, SIZE);
+
+    test(src, GDT_Byte, dst, GDT_Byte, 1024 * 1024 + 1, 2, 1);
+    test(src, GDT_Byte, dst, GDT_Byte, 1024 * 1024 + 1, 3, 1);
+#if defined(HAVE_SSSE3_AT_COMPILE_TIME) && defined(DEBUG)
+    {
+        CPLConfigOptionSetter oSetters("GDAL_USE_SSSE3", "NO", false);
+        test(src, GDT_Byte, dst, GDT_Byte, 1024 * 1024 + 1, 3, 10,
+             " (no SSSE3)");
+    }
+#endif
+    test(src, GDT_Byte, dst, GDT_Byte, 1024 * 1024 + 1, 4, 1);
+    test(src, GDT_Byte, dst, GDT_Byte, 1024 * 1024 + 1, 5, 1);
+#if defined(HAVE_SSSE3_AT_COMPILE_TIME) && defined(DEBUG)
+    {
+        CPLConfigOptionSetter oSetters("GDAL_USE_SSSE3", "NO", false);
+        test(src, GDT_Byte, dst, GDT_Byte, 1024 * 1024 + 1, 5, 10,
+             " (no SSSE3)");
+    }
+#endif
+    test(src, GDT_Byte, dst, GDT_Byte, 1024 * 1024 + 1, 16 + 1, 10);
+#if defined(HAVE_SSSE3_AT_COMPILE_TIME) && defined(DEBUG)
+    {
+        CPLConfigOptionSetter oSetters("GDAL_USE_SSSE3", "NO", false);
+        test(src, GDT_Byte, dst, GDT_Byte, 1024 * 1024 + 1, 16 + 1, 10,
+             " (no SSSE3)");
+    }
+#endif
+    test(src, GDT_Byte, dst, GDT_Byte, 1024 * 1024 + 1, 100, 10);
+    test(src, GDT_Byte, dst, GDT_Byte, 70 * 1024 + 1, 1024 + 1, 10);
+#if defined(HAVE_SSSE3_AT_COMPILE_TIME) && defined(DEBUG)
+    {
+        CPLConfigOptionSetter oSetters("GDAL_USE_SSSE3", "NO", false);
+        test(src, GDT_Byte, dst, GDT_Byte, 70 * 1024 + 1, 1024 + 1, 10,
+             " (no SSSE3)");
+    }
+#endif
+    test(src, GDT_Byte, dst, GDT_Byte, 7 * 1024 + 1, 10 * 1024 + 1, 10);
+#if defined(HAVE_SSSE3_AT_COMPILE_TIME) && defined(DEBUG)
+    {
+        CPLConfigOptionSetter oSetters("GDAL_USE_SSSE3", "NO", false);
+        test(src, GDT_Byte, dst, GDT_Byte, 7 * 1024 + 1, 10 * 1024 + 1, 10,
+             " (no SSSE3)");
+    }
+#endif
+
+    VSIFree(src);
+    VSIFree(dst);
+    return 0;
+}

From e751efd7ba7ce5f89d2cb45eca56722b29614a19 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Sun, 5 Jan 2025 02:26:21 +0100
Subject: [PATCH 26/40] GDALTranspose2D(): improve readability

---
 gcore/rasterio.cpp | 89 ++++++++++++++++++++++++----------------------
 1 file changed, 46 insertions(+), 43 deletions(-)

diff --git a/gcore/rasterio.cpp b/gcore/rasterio.cpp
index d4949efbf47e..8e048fee8e2b 100644
--- a/gcore/rasterio.cpp
+++ b/gcore/rasterio.cpp
@@ -5682,8 +5682,9 @@ template <class DST, bool DST_IS_COMPLEX>
 static void GDALTranspose2D(const void *pSrc, GDALDataType eSrcType, DST *pDst,
                             size_t nSrcWidth, size_t nSrcHeight)
 {
-#define GDALTranspose2D_internal(SRC_TYPE_CST, SRC_TYPE)                       \
-    case SRC_TYPE_CST:                                                         \
+#define CALL_GDALTranspose2D_internal(SRC_TYPE)                                \
+    do                                                                         \
+    {                                                                          \
         if constexpr (DST_IS_COMPLEX)                                          \
         {                                                                      \
             GDALTranspose2DSingleToComplex(                                    \
@@ -5695,10 +5696,11 @@ static void GDALTranspose2D(const void *pSrc, GDALDataType eSrcType, DST *pDst,
             GDALTranspose2DSingleToSingle(static_cast<const SRC_TYPE *>(pSrc), \
                                           pDst, nSrcWidth, nSrcHeight);        \
         }                                                                      \
-        break
+    } while (0)
 
-#define GDALTranspose2DComplex_internal(SRC_TYPE_CST, SRC_TYPE)                \
-    case SRC_TYPE_CST:                                                         \
+#define CALL_GDALTranspose2DComplex_internal(SRC_TYPE)                         \
+    do                                                                         \
+    {                                                                          \
         if constexpr (DST_IS_COMPLEX)                                          \
         {                                                                      \
             GDALTranspose2DComplexToComplex(                                   \
@@ -5711,31 +5713,33 @@ static void GDALTranspose2D(const void *pSrc, GDALDataType eSrcType, DST *pDst,
                 static_cast<const SRC_TYPE *>(pSrc), pDst, nSrcWidth,          \
                 nSrcHeight);                                                   \
         }                                                                      \
-        break
+    } while (0)
 
+    // clang-format off
     switch (eSrcType)
     {
-        GDALTranspose2D_internal(GDT_Byte, uint8_t);
-        GDALTranspose2D_internal(GDT_Int8, int8_t);
-        GDALTranspose2D_internal(GDT_UInt16, uint16_t);
-        GDALTranspose2D_internal(GDT_Int16, int16_t);
-        GDALTranspose2D_internal(GDT_UInt32, uint32_t);
-        GDALTranspose2D_internal(GDT_Int32, int32_t);
-        GDALTranspose2D_internal(GDT_UInt64, uint64_t);
-        GDALTranspose2D_internal(GDT_Int64, int64_t);
-        GDALTranspose2D_internal(GDT_Float32, float);
-        GDALTranspose2D_internal(GDT_Float64, double);
-        GDALTranspose2DComplex_internal(GDT_CInt16, int16_t);
-        GDALTranspose2DComplex_internal(GDT_CInt32, int32_t);
-        GDALTranspose2DComplex_internal(GDT_CFloat32, float);
-        GDALTranspose2DComplex_internal(GDT_CFloat64, double);
+        case GDT_Byte:     CALL_GDALTranspose2D_internal(uint8_t); break;
+        case GDT_Int8:     CALL_GDALTranspose2D_internal(int8_t); break;
+        case GDT_UInt16:   CALL_GDALTranspose2D_internal(uint16_t); break;
+        case GDT_Int16:    CALL_GDALTranspose2D_internal(int16_t); break;
+        case GDT_UInt32:   CALL_GDALTranspose2D_internal(uint32_t); break;
+        case GDT_Int32:    CALL_GDALTranspose2D_internal(int32_t); break;
+        case GDT_UInt64:   CALL_GDALTranspose2D_internal(uint64_t); break;
+        case GDT_Int64:    CALL_GDALTranspose2D_internal(int64_t); break;
+        case GDT_Float32:  CALL_GDALTranspose2D_internal(float); break;
+        case GDT_Float64:  CALL_GDALTranspose2D_internal(double); break;
+        case GDT_CInt16:   CALL_GDALTranspose2DComplex_internal(int16_t); break;
+        case GDT_CInt32:   CALL_GDALTranspose2DComplex_internal(int32_t); break;
+        case GDT_CFloat32: CALL_GDALTranspose2DComplex_internal(float); break;
+        case GDT_CFloat64: CALL_GDALTranspose2DComplex_internal(double); break;
         case GDT_Unknown:
         case GDT_TypeCount:
             break;
     }
+        // clang-format on
 
-#undef GDALTranspose2D_internal
-#undef GDALTranspose2DComplex_internal
+#undef CALL_GDALTranspose2D_internal
+#undef CALL_GDALTranspose2DComplex_internal
 }
 
 /************************************************************************/
@@ -5840,33 +5844,32 @@ void GDALTranspose2D(const void *pSrc, GDALDataType eSrcType, void *pDst,
 #endif
     }
 
-#define GDALTranspose2D_internal(DST_TYPE_CST, DST_TYPE, DST_IS_COMPLEX)       \
-    case DST_TYPE_CST:                                                         \
-        GDALTranspose2D<DST_TYPE, DST_IS_COMPLEX>(                             \
-            pSrc, eSrcType, static_cast<DST_TYPE *>(pDst), nSrcWidth,          \
-            nSrcHeight);                                                       \
-        break
+#define CALL_GDALTranspose2D_internal(DST_TYPE, DST_IS_COMPLEX)                \
+    GDALTranspose2D<DST_TYPE, DST_IS_COMPLEX>(                                 \
+        pSrc, eSrcType, static_cast<DST_TYPE *>(pDst), nSrcWidth, nSrcHeight)
 
+    // clang-format off
     switch (eDstType)
     {
-        GDALTranspose2D_internal(GDT_Byte, uint8_t, false);
-        GDALTranspose2D_internal(GDT_Int8, int8_t, false);
-        GDALTranspose2D_internal(GDT_UInt16, uint16_t, false);
-        GDALTranspose2D_internal(GDT_Int16, int16_t, false);
-        GDALTranspose2D_internal(GDT_UInt32, uint32_t, false);
-        GDALTranspose2D_internal(GDT_Int32, int32_t, false);
-        GDALTranspose2D_internal(GDT_UInt64, uint64_t, false);
-        GDALTranspose2D_internal(GDT_Int64, int64_t, false);
-        GDALTranspose2D_internal(GDT_Float32, float, false);
-        GDALTranspose2D_internal(GDT_Float64, double, false);
-        GDALTranspose2D_internal(GDT_CInt16, int16_t, true);
-        GDALTranspose2D_internal(GDT_CInt32, int32_t, true);
-        GDALTranspose2D_internal(GDT_CFloat32, float, true);
-        GDALTranspose2D_internal(GDT_CFloat64, double, true);
+        case GDT_Byte:     CALL_GDALTranspose2D_internal(uint8_t, false); break;
+        case GDT_Int8:     CALL_GDALTranspose2D_internal(int8_t, false); break;
+        case GDT_UInt16:   CALL_GDALTranspose2D_internal(uint16_t, false); break;
+        case GDT_Int16:    CALL_GDALTranspose2D_internal(int16_t, false); break;
+        case GDT_UInt32:   CALL_GDALTranspose2D_internal(uint32_t, false); break;
+        case GDT_Int32:    CALL_GDALTranspose2D_internal(int32_t, false); break;
+        case GDT_UInt64:   CALL_GDALTranspose2D_internal(uint64_t, false); break;
+        case GDT_Int64:    CALL_GDALTranspose2D_internal(int64_t, false); break;
+        case GDT_Float32:  CALL_GDALTranspose2D_internal(float, false); break;
+        case GDT_Float64:  CALL_GDALTranspose2D_internal(double, false); break;
+        case GDT_CInt16:   CALL_GDALTranspose2D_internal(int16_t, true); break;
+        case GDT_CInt32:   CALL_GDALTranspose2D_internal(int32_t, true); break;
+        case GDT_CFloat32: CALL_GDALTranspose2D_internal(float, true); break;
+        case GDT_CFloat64: CALL_GDALTranspose2D_internal(double, true); break;
         case GDT_Unknown:
         case GDT_TypeCount:
             break;
     }
+        // clang-format on
 
-#undef GDALTranspose2D_internal
+#undef CALL_GDALTranspose2D_internal
 }

From e487adfbd89fe383ee792395fd8293d9c9efc9bd Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Sun, 5 Jan 2025 06:24:51 +0100
Subject: [PATCH 27/40] GDALInterleave2Byte() and GDALInterleave4Byte():
 provide SSE2 implementation for ICC and MSVC

---
 autotest/cpp/test_gdal.cpp |  32 ++++++++++-
 gcore/rasterio.cpp         | 115 ++++++++++++++++++++++++++++++++++++-
 gcore/rasterio_ssse3.cpp   |   2 +-
 3 files changed, 144 insertions(+), 5 deletions(-)

diff --git a/autotest/cpp/test_gdal.cpp b/autotest/cpp/test_gdal.cpp
index 0a5a160c521a..7cf821258994 100644
--- a/autotest/cpp/test_gdal.cpp
+++ b/autotest/cpp/test_gdal.cpp
@@ -5011,7 +5011,21 @@ TEST_F(test_gdal, GDALTranspose2D_Byte_optims)
         }
     }
 
-    // Optim H = 2
+    // Optim H = 2 with W < 16
+    {
+        constexpr int W = 15;
+        constexpr int H = 2;
+        GDALTranspose2D(in.data(), GDT_Byte, out.data(), GDT_Byte, W, H);
+        for (int y = 0; y < H; ++y)
+        {
+            for (int x = 0; x < W; ++x)
+            {
+                EXPECT_EQ(out[x * H + y], in[y * W + x]);
+            }
+        }
+    }
+
+    // Optim H = 2 with W >= 16
     {
         constexpr int W = 19;
         constexpr int H = 2;
@@ -5039,7 +5053,21 @@ TEST_F(test_gdal, GDALTranspose2D_Byte_optims)
         }
     }
 
-    // Optim H = 4
+    // Optim H = 4 with H < 16
+    {
+        constexpr int W = 15;
+        constexpr int H = 4;
+        GDALTranspose2D(in.data(), GDT_Byte, out.data(), GDT_Byte, W, H);
+        for (int y = 0; y < H; ++y)
+        {
+            for (int x = 0; x < W; ++x)
+            {
+                EXPECT_EQ(out[x * H + y], in[y * W + x]);
+            }
+        }
+    }
+
+    // Optim H = 4 with H >= 16
     {
         constexpr int W = 19;
         constexpr int H = 4;
diff --git a/gcore/rasterio.cpp b/gcore/rasterio.cpp
index 8e048fee8e2b..be0d6be871bc 100644
--- a/gcore/rasterio.cpp
+++ b/gcore/rasterio.cpp
@@ -5746,6 +5746,44 @@ static void GDALTranspose2D(const void *pSrc, GDALDataType eSrcType, DST *pDst,
 /*                      GDALInterleave2Byte()                           */
 /************************************************************************/
 
+#if defined(HAVE_SSE2) &&                                                      \
+    (!defined(__GNUC__) || defined(__INTEL_CLANG_COMPILER))
+
+// ICC autovectorizer doesn't do a good job at generating good SSE code,
+// at least with icx 2024.0.2.20231213, but it nicely unrolls the below loop.
+#if defined(__GNUC__)
+__attribute__((noinline))
+#endif
+static void
+GDALInterleave2Byte(const uint8_t *CPL_RESTRICT pSrc,
+                    uint8_t *CPL_RESTRICT pDst, size_t nIters)
+{
+    size_t i = 0;
+    constexpr size_t VALS_PER_ITER = 16;
+    for (i = 0; i + VALS_PER_ITER <= nIters; i += VALS_PER_ITER)
+    {
+        __m128i xmm0 =
+            _mm_loadu_si128(reinterpret_cast<__m128i const *>(pSrc + i));
+        __m128i xmm1 = _mm_loadu_si128(
+            reinterpret_cast<__m128i const *>(pSrc + i + nIters));
+        _mm_storeu_si128(reinterpret_cast<__m128i *>(pDst + 2 * i),
+                         _mm_unpacklo_epi8(xmm0, xmm1));
+        _mm_storeu_si128(
+            reinterpret_cast<__m128i *>(pDst + 2 * i + VALS_PER_ITER),
+            _mm_unpackhi_epi8(xmm0, xmm1));
+    }
+#if defined(__clang__)
+#pragma clang loop vectorize(disable)
+#endif
+    for (; i < nIters; ++i)
+    {
+        pDst[2 * i + 0] = pSrc[i + 0 * nIters];
+        pDst[2 * i + 1] = pSrc[i + 1 * nIters];
+    }
+}
+
+#else
+
 #if defined(__GNUC__) && !defined(__clang__)
 __attribute__((optimize("tree-vectorize")))
 #endif
@@ -5756,7 +5794,7 @@ static void
 GDALInterleave2Byte(const uint8_t *CPL_RESTRICT pSrc,
                     uint8_t *CPL_RESTRICT pDst, size_t nIters)
 {
-#if defined(__clang__)
+#if defined(__clang__) && !defined(__INTEL_CLANG_COMPILER)
 #pragma clang loop vectorize(enable)
 #endif
     for (size_t i = 0; i < nIters; ++i)
@@ -5766,10 +5804,81 @@ GDALInterleave2Byte(const uint8_t *CPL_RESTRICT pSrc,
     }
 }
 
+#endif
+
 /************************************************************************/
 /*                      GDALInterleave4Byte()                           */
 /************************************************************************/
 
+#if defined(HAVE_SSE2) &&                                                      \
+    (!defined(__GNUC__) || defined(__INTEL_CLANG_COMPILER))
+
+// ICC autovectorizer doesn't do a good job at generating good SSE code,
+// at least with icx 2024.0.2.20231213, but it nicely unrolls the below loop.
+#if defined(__GNUC__)
+__attribute__((noinline))
+#endif
+static void
+GDALInterleave4Byte(const uint8_t *CPL_RESTRICT pSrc,
+                    uint8_t *CPL_RESTRICT pDst, size_t nIters)
+{
+    size_t i = 0;
+    constexpr size_t VALS_PER_ITER = 16;
+    for (i = 0; i + VALS_PER_ITER <= nIters; i += VALS_PER_ITER)
+    {
+        __m128i xmm0 = _mm_loadu_si128(
+            reinterpret_cast<__m128i const *>(pSrc + i + 0 * nIters));
+        __m128i xmm1 = _mm_loadu_si128(
+            reinterpret_cast<__m128i const *>(pSrc + i + 1 * nIters));
+        __m128i xmm2 = _mm_loadu_si128(
+            reinterpret_cast<__m128i const *>(pSrc + i + 2 * nIters));
+        __m128i xmm3 = _mm_loadu_si128(
+            reinterpret_cast<__m128i const *>(pSrc + i + 3 * nIters));
+        auto tmp0 = _mm_unpacklo_epi8(
+            xmm0,
+            xmm1);  // (xmm0_0, xmm1_0, xmm0_1, xmm1_1, xmm0_2, xmm1_2, ...)
+        auto tmp1 = _mm_unpackhi_epi8(
+            xmm0,
+            xmm1);  // (xmm0_8, xmm1_8, xmm0_9, xmm1_9, xmm0_10, xmm1_10, ...)
+        auto tmp2 = _mm_unpacklo_epi8(
+            xmm2,
+            xmm3);  // (xmm2_0, xmm3_0, xmm2_1, xmm3_1, xmm2_2, xmm3_2, ...)
+        auto tmp3 = _mm_unpackhi_epi8(
+            xmm2,
+            xmm3);  // (xmm2_8, xmm3_8, xmm2_9, xmm3_9, xmm2_10, xmm3_10, ...)
+        auto tmp2_0 = _mm_unpacklo_epi16(
+            tmp0,
+            tmp2);  // (xmm0_0, xmm1_0, xmm2_0, xmm3_0, xmm0_1, xmm1_1, xmm2_1, xmm3_1, ...)
+        auto tmp2_1 = _mm_unpackhi_epi16(tmp0, tmp2);
+        auto tmp2_2 = _mm_unpacklo_epi16(tmp1, tmp3);
+        auto tmp2_3 = _mm_unpackhi_epi16(tmp1, tmp3);
+        _mm_storeu_si128(
+            reinterpret_cast<__m128i *>(pDst + 4 * i + 0 * VALS_PER_ITER),
+            tmp2_0);
+        _mm_storeu_si128(
+            reinterpret_cast<__m128i *>(pDst + 4 * i + 1 * VALS_PER_ITER),
+            tmp2_1);
+        _mm_storeu_si128(
+            reinterpret_cast<__m128i *>(pDst + 4 * i + 2 * VALS_PER_ITER),
+            tmp2_2);
+        _mm_storeu_si128(
+            reinterpret_cast<__m128i *>(pDst + 4 * i + 3 * VALS_PER_ITER),
+            tmp2_3);
+    }
+#if defined(__clang__)
+#pragma clang loop vectorize(disable)
+#endif
+    for (; i < nIters; ++i)
+    {
+        pDst[4 * i + 0] = pSrc[i + 0 * nIters];
+        pDst[4 * i + 1] = pSrc[i + 1 * nIters];
+        pDst[4 * i + 2] = pSrc[i + 2 * nIters];
+        pDst[4 * i + 3] = pSrc[i + 3 * nIters];
+    }
+}
+
+#else
+
 #if defined(__GNUC__) && !defined(__clang__)
 __attribute__((optimize("tree-vectorize")))
 #endif
@@ -5780,7 +5889,7 @@ static void
 GDALInterleave4Byte(const uint8_t *CPL_RESTRICT pSrc,
                     uint8_t *CPL_RESTRICT pDst, size_t nIters)
 {
-#if defined(__clang__)
+#if defined(__clang__) && !defined(__INTEL_CLANG_COMPILER)
 #pragma clang loop vectorize(enable)
 #endif
     for (size_t i = 0; i < nIters; ++i)
@@ -5792,6 +5901,8 @@ GDALInterleave4Byte(const uint8_t *CPL_RESTRICT pSrc,
     }
 }
 
+#endif
+
 /************************************************************************/
 /*                        GDALTranspose2D()                             */
 /************************************************************************/
diff --git a/gcore/rasterio_ssse3.cpp b/gcore/rasterio_ssse3.cpp
index e3f9636a7c27..b09fb4726fc8 100644
--- a/gcore/rasterio_ssse3.cpp
+++ b/gcore/rasterio_ssse3.cpp
@@ -286,7 +286,7 @@ static void
 GDALInterleave3Byte_SSSE3(const uint8_t *CPL_RESTRICT pSrc,
                           uint8_t *CPL_RESTRICT pDst, size_t nIters)
 {
-#if defined(__clang__)
+#if defined(__clang__) && !defined(__INTEL_CLANG_COMPILER)
 #pragma clang loop vectorize(enable)
 #endif
     for (size_t i = 0; i < nIters; ++i)

From f9a6430b71fe2d456497f12456105b18c8e7ef3f Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Sun, 5 Jan 2025 14:21:13 +0100
Subject: [PATCH 28/40] GDALInterleave3Byte_SSSE3(): provide implementation for
 ICC and MSVC

---
 autotest/cpp/test_gdal.cpp |  16 +++-
 gcore/rasterio_ssse3.cpp   | 151 ++++++++++++++++++++++++++++++++++---
 2 files changed, 155 insertions(+), 12 deletions(-)

diff --git a/autotest/cpp/test_gdal.cpp b/autotest/cpp/test_gdal.cpp
index 7cf821258994..7ae64a189bad 100644
--- a/autotest/cpp/test_gdal.cpp
+++ b/autotest/cpp/test_gdal.cpp
@@ -5039,7 +5039,21 @@ TEST_F(test_gdal, GDALTranspose2D_Byte_optims)
         }
     }
 
-    // SSSE3 optim H = 3
+    // SSSE3 optim H = 3 with W < 16
+    {
+        constexpr int W = 15;
+        constexpr int H = 3;
+        GDALTranspose2D(in.data(), GDT_Byte, out.data(), GDT_Byte, W, H);
+        for (int y = 0; y < H; ++y)
+        {
+            for (int x = 0; x < W; ++x)
+            {
+                EXPECT_EQ(out[x * H + y], in[y * W + x]);
+            }
+        }
+    }
+
+    // SSSE3 optim H = 3 with W >= 16
     {
         constexpr int W = 19;
         constexpr int H = 3;
diff --git a/gcore/rasterio_ssse3.cpp b/gcore/rasterio_ssse3.cpp
index b09fb4726fc8..9bf80e34096a 100644
--- a/gcore/rasterio_ssse3.cpp
+++ b/gcore/rasterio_ssse3.cpp
@@ -272,10 +272,148 @@ void GDALDeinterleave4UInt16_SSSE3(const GUInt16* CPL_RESTRICT panSrc,
 }
 #endif
 
+/************************************************************************/
+/*                               loadu()                                */
+/************************************************************************/
+
+inline __m128i loadu(const uint8_t *pSrc, size_t i, size_t srcStride)
+{
+    return _mm_loadu_si128(
+        reinterpret_cast<const __m128i *>(pSrc + i * srcStride));
+}
+
+/************************************************************************/
+/*                               storeu()                               */
+/************************************************************************/
+
+inline void storeu(uint8_t *pDst, size_t i, size_t dstStride, __m128i reg)
+{
+    _mm_storeu_si128(reinterpret_cast<__m128i *>(pDst + i * dstStride), reg);
+}
+
 /************************************************************************/
 /*                      GDALInterleave3Byte_SSSE3()                     */
 /************************************************************************/
 
+#if (!defined(__GNUC__) || defined(__INTEL_CLANG_COMPILER))
+
+inline __m128i GDAL_mm_or_3_si128(__m128i r0, __m128i r1, __m128i r2)
+{
+    return _mm_or_si128(_mm_or_si128(r0, r1), r2);
+}
+
+// ICC autovectorizer doesn't do a good job at generating good SSE code,
+// at least with icx 2024.0.2.20231213, but it nicely unrolls the below loop.
+#if defined(__GNUC__)
+__attribute__((noinline))
+#endif
+static void
+GDALInterleave3Byte_SSSE3(const uint8_t *CPL_RESTRICT pSrc,
+                          uint8_t *CPL_RESTRICT pDst, size_t nIters)
+{
+    size_t i = 0;
+    constexpr size_t VALS_PER_ITER = 16;
+
+    if (nIters >= VALS_PER_ITER)
+    {
+        // clang-format off
+        constexpr char X = -1;
+        // How to dispatch 16 values of row=0 onto 3x16 bytes
+        const __m128i xmm_shuffle00 = _mm_setr_epi8(0, X, X,
+                                                    1, X, X,
+                                                    2, X, X,
+                                                    3, X, X,
+                                                    4, X, X,
+                                                    5);
+        const __m128i xmm_shuffle01 = _mm_setr_epi8(   X, X,
+                                                    6, X, X,
+                                                    7, X, X,
+                                                    8, X, X,
+                                                    9, X, X,
+                                                    10,X);
+        const __m128i xmm_shuffle02 = _mm_setr_epi8(       X,
+                                                    11, X, X,
+                                                    12, X, X,
+                                                    13, X, X,
+                                                    14, X, X,
+                                                    15, X, X);
+
+        // How to dispatch 16 values of row=1 onto 3x16 bytes
+        const __m128i xmm_shuffle10 = _mm_setr_epi8(X, 0, X,
+                                                    X, 1, X,
+                                                    X, 2, X,
+                                                    X, 3, X,
+                                                    X, 4, X,
+                                                    X);
+        const __m128i xmm_shuffle11 = _mm_setr_epi8(   5, X,
+                                                    X, 6, X,
+                                                    X, 7, X,
+                                                    X, 8, X,
+                                                    X, 9, X,
+                                                    X,10);
+        const __m128i xmm_shuffle12 = _mm_setr_epi8(       X,
+                                                    X, 11, X,
+                                                    X, 12, X,
+                                                    X, 13, X,
+                                                    X, 14, X,
+                                                    X, 15, X);
+
+        // How to dispatch 16 values of row=2 onto 3x16 bytes
+        const __m128i xmm_shuffle20 = _mm_setr_epi8(X, X, 0,
+                                                    X, X, 1,
+                                                    X, X, 2,
+                                                    X, X, 3,
+                                                    X, X, 4,
+                                                    X);
+        const __m128i xmm_shuffle21 = _mm_setr_epi8(   X, 5,
+                                                    X, X, 6,
+                                                    X, X, 7,
+                                                    X, X, 8,
+                                                    X, X, 9,
+                                                    X, X);
+        const __m128i xmm_shuffle22 = _mm_setr_epi8(      10,
+                                                    X, X, 11,
+                                                    X, X, 12,
+                                                    X, X, 13,
+                                                    X, X, 14,
+                                                    X, X, 15);
+        // clang-format on
+
+        for (; i + VALS_PER_ITER <= nIters; i += VALS_PER_ITER)
+        {
+#define LOAD(x) __m128i xmm##x = loadu(pSrc + i, x, nIters)
+            LOAD(0);
+            LOAD(1);
+            LOAD(2);
+
+#define SHUFFLE(x, y) _mm_shuffle_epi8(xmm##y, xmm_shuffle##y##x)
+#define COMBINE_3(x)                                                           \
+    GDAL_mm_or_3_si128(SHUFFLE(x, 0), SHUFFLE(x, 1), SHUFFLE(x, 2))
+
+#define STORE(x)                                                               \
+    storeu(pDst, 3 * (i / VALS_PER_ITER) + x, VALS_PER_ITER, COMBINE_3(x))
+            STORE(0);
+            STORE(1);
+            STORE(2);
+#undef LOAD
+#undef COMBINE_3
+#undef SHUFFLE
+#undef STORE
+        }
+    }
+
+    for (; i < nIters; ++i)
+    {
+#define INTERLEAVE(x) pDst[3 * i + x] = pSrc[i + x * nIters]
+        INTERLEAVE(0);
+        INTERLEAVE(1);
+        INTERLEAVE(2);
+#undef INTERLEAVE
+    }
+}
+
+#else
+
 #if defined(__GNUC__) && !defined(__clang__)
 __attribute__((optimize("tree-vectorize")))
 #endif
@@ -297,21 +435,12 @@ GDALInterleave3Byte_SSSE3(const uint8_t *CPL_RESTRICT pSrc,
     }
 }
 
+#endif
+
 /************************************************************************/
 /*                      GDALInterleave5Byte_SSSE3()                     */
 /************************************************************************/
 
-inline __m128i loadu(const uint8_t *pSrc, size_t i, size_t srcStride)
-{
-    return _mm_loadu_si128(
-        reinterpret_cast<const __m128i *>(pSrc + i * srcStride));
-}
-
-inline void storeu(uint8_t *pDst, size_t i, size_t dstStride, __m128i reg)
-{
-    _mm_storeu_si128(reinterpret_cast<__m128i *>(pDst + i * dstStride), reg);
-}
-
 inline __m128i GDAL_mm_or_5_si128(__m128i r0, __m128i r1, __m128i r2,
                                   __m128i r3, __m128i r4)
 {

From 2c7d45864a2130ad5525c54e1f93b5aa8e165dbb Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Sun, 5 Jan 2025 16:14:03 +0100
Subject: [PATCH 29/40] GDALDeinterleave(): use Byte --> Byte optimization also
 for Int8 --> Int8 case

---
 gcore/rasterio.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gcore/rasterio.cpp b/gcore/rasterio.cpp
index be0d6be871bc..d6ba6796d1a6 100644
--- a/gcore/rasterio.cpp
+++ b/gcore/rasterio.cpp
@@ -5586,7 +5586,7 @@ void GDALDeinterleave(const void *pSourceBuffer, GDALDataType eSourceDT,
 {
     if (eSourceDT == eDestDT)
     {
-        if (eSourceDT == GDT_Byte)
+        if (eSourceDT == GDT_Byte || eSourceDT == GDT_Int8)
         {
             if (nComponents == 3)
             {

From 3f217b6f42b7e15fa33edf7428ed8eff7c598dbc Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Sun, 5 Jan 2025 18:27:32 +0100
Subject: [PATCH 30/40] Implement VRTProcessedDataset::IRasterIO()

---
 autotest/gdrivers/vrtprocesseddataset.py | 190 ++++++++++++++++++++++
 frmts/vrt/vrtdataset.h                   |  15 ++
 frmts/vrt/vrtprocesseddataset.cpp        | 192 ++++++++++++++++++++++-
 3 files changed, 389 insertions(+), 8 deletions(-)

diff --git a/autotest/gdrivers/vrtprocesseddataset.py b/autotest/gdrivers/vrtprocesseddataset.py
index e3ff9a1bf787..63ff0749dde5 100755
--- a/autotest/gdrivers/vrtprocesseddataset.py
+++ b/autotest/gdrivers/vrtprocesseddataset.py
@@ -1326,3 +1326,193 @@ def test_vrtprocesseddataset_OutputBands():
         match="Invalid value for OutputBands.dataType",
     ):
         gdal.Open("data/vrt/processed_OutputBands_USER_PROVIDED_invalid_type.vrt")
+
+
+###############################################################################
+# Test VRTProcessedDataset::RasterIO()
+
+
+def test_vrtprocesseddataset_RasterIO(tmp_vsimem):
+
+    src_filename = str(tmp_vsimem / "src.tif")
+    src_ds = gdal.GetDriverByName("GTiff").Create(src_filename, 2, 3, 4)
+    src_ds.GetRasterBand(1).WriteArray(np.array([[1, 2], [3, 4], [5, 6]]))
+    src_ds.GetRasterBand(2).WriteArray(np.array([[7, 8], [9, 10], [11, 12]]))
+    src_ds.GetRasterBand(3).WriteArray(np.array([[13, 14], [15, 16], [17, 18]]))
+    src_ds.GetRasterBand(4).WriteArray(np.array([[19, 20], [21, 22], [23, 24]]))
+    src_ds.BuildOverviews("NEAR", [2])
+    src_ds = None
+
+    vrt_content = f"""<VRTDataset subclass='VRTProcessedDataset'>
+    <Input>
+        <SourceFilename>{src_filename}</SourceFilename>
+    </Input>
+    <ProcessingSteps>
+        <Step name="Affine combination of band values">
+            <Algorithm>BandAffineCombination</Algorithm>
+            <Argument name="coefficients_1">0,0,1,0,0</Argument>
+            <Argument name="coefficients_2">0,0,0,1,0</Argument>
+            <Argument name="coefficients_3">0,0,0,0,1</Argument>
+            <Argument name="coefficients_4">0,1,0,0,0</Argument>
+        </Step>
+    </ProcessingSteps>
+    </VRTDataset>
+        """
+
+    ds = gdal.Open(vrt_content)
+    assert ds.RasterXSize == 2
+    assert ds.RasterYSize == 3
+    assert ds.RasterCount == 4
+
+    # Optimized code path with INTERLEAVE=BAND
+    np.testing.assert_equal(
+        ds.ReadAsArray(),
+        np.array(
+            [
+                [[7, 8], [9, 10], [11, 12]],
+                [[13, 14], [15, 16], [17, 18]],
+                [[19, 20], [21, 22], [23, 24]],
+                [[1, 2], [3, 4], [5, 6]],
+            ]
+        ),
+    )
+
+    # Optimized code path with INTERLEAVE=BAND but buf_type != native type
+    np.testing.assert_equal(
+        ds.ReadAsArray(buf_type=gdal.GDT_Int16),
+        np.array(
+            [
+                [[7, 8], [9, 10], [11, 12]],
+                [[13, 14], [15, 16], [17, 18]],
+                [[19, 20], [21, 22], [23, 24]],
+                [[1, 2], [3, 4], [5, 6]],
+            ]
+        ),
+    )
+
+    # Optimized code path with INTERLEAVE=BAND
+    np.testing.assert_equal(
+        ds.ReadAsArray(1, 2, 1, 1),
+        np.array([[[12]], [[18]], [[24]], [[6]]]),
+    )
+
+    # Optimized code path with INTERLEAVE=PIXEL
+    np.testing.assert_equal(
+        ds.ReadAsArray(interleave="PIXEL"),
+        np.array(
+            [
+                [[7, 13, 19, 1], [8, 14, 20, 2]],
+                [[9, 15, 21, 3], [10, 16, 22, 4]],
+                [[11, 17, 23, 5], [12, 18, 24, 6]],
+            ]
+        ),
+    )
+
+    # Optimized code path with INTERLEAVE=PIXEL but buf_type != native type
+    np.testing.assert_equal(
+        ds.ReadAsArray(interleave="PIXEL", buf_type=gdal.GDT_Int16),
+        np.array(
+            [
+                [[7, 13, 19, 1], [8, 14, 20, 2]],
+                [[9, 15, 21, 3], [10, 16, 22, 4]],
+                [[11, 17, 23, 5], [12, 18, 24, 6]],
+            ]
+        ),
+    )
+
+    # Optimized code path with INTERLEAVE=PIXEL
+    np.testing.assert_equal(
+        ds.ReadAsArray(1, 2, 1, 1, interleave="PIXEL"),
+        np.array([[[12, 18, 24, 6]]]),
+    )
+
+    # Not optimized INTERLEAVE=BAND because not enough bands
+    np.testing.assert_equal(
+        ds.ReadAsArray(band_list=[1, 2, 3]),
+        np.array(
+            [
+                [[7, 8], [9, 10], [11, 12]],
+                [[13, 14], [15, 16], [17, 18]],
+                [[19, 20], [21, 22], [23, 24]],
+            ]
+        ),
+    )
+
+    # Not optimized INTERLEAVE=BAND because of out-of-order band list
+    np.testing.assert_equal(
+        ds.ReadAsArray(band_list=[4, 1, 2, 3]),
+        np.array(
+            [
+                [[1, 2], [3, 4], [5, 6]],
+                [[7, 8], [9, 10], [11, 12]],
+                [[13, 14], [15, 16], [17, 18]],
+                [[19, 20], [21, 22], [23, 24]],
+            ]
+        ),
+    )
+
+    # Not optimized INTERLEAVE=PIXEL because of out-of-order band list
+    np.testing.assert_equal(
+        ds.ReadAsArray(interleave="PIXEL", band_list=[4, 1, 2, 3]),
+        np.array(
+            [
+                [[1, 7, 13, 19], [2, 8, 14, 20]],
+                [[3, 9, 15, 21], [4, 10, 16, 22]],
+                [[5, 11, 17, 23], [6, 12, 18, 24]],
+            ]
+        ),
+    )
+
+    # Optimized code path with overviews
+    assert ds.GetRasterBand(1).GetOverview(0).XSize == 1
+    assert ds.GetRasterBand(1).GetOverview(0).YSize == 2
+    np.testing.assert_equal(
+        ds.ReadAsArray(buf_xsize=1, buf_ysize=2),
+        np.array([[[7], [11]], [[13], [17]], [[19], [23]], [[1], [5]]]),
+    )
+
+    # Non-optimized code path with overviews
+    np.testing.assert_equal(
+        ds.ReadAsArray(buf_xsize=1, buf_ysize=1),
+        np.array([[[11]], [[17]], [[23]], [[5]]]),
+    )
+
+    # Test buffer splitting
+    with gdal.config_option("VRT_PROCESSED_DATASET_ALLOWED_RAM_USAGE", "96"):
+        ds = gdal.Open(vrt_content)
+
+    # Optimized code path with INTERLEAVE=BAND
+    np.testing.assert_equal(
+        ds.ReadAsArray(),
+        np.array(
+            [
+                [[7, 8], [9, 10], [11, 12]],
+                [[13, 14], [15, 16], [17, 18]],
+                [[19, 20], [21, 22], [23, 24]],
+                [[1, 2], [3, 4], [5, 6]],
+            ]
+        ),
+    )
+
+    # I/O error
+    gdal.GetDriverByName("GTiff").Create(
+        src_filename, 1024, 1024, 4, options=["TILED=YES"]
+    )
+    f = gdal.VSIFOpenL(src_filename, "rb+")
+    gdal.VSIFTruncateL(f, 4096)
+    gdal.VSIFCloseL(f)
+
+    ds = gdal.Open(vrt_content)
+
+    # Error in INTERLEAVE=BAND optimized code path
+    with pytest.raises(Exception):
+        ds.ReadAsArray()
+
+    # Error in INTERLEAVE=PIXEL optimized code path
+    with pytest.raises(Exception):
+        ds.ReadAsArray(interleave="PIXEL")
+
+    with gdal.config_option("VRT_PROCESSED_DATASET_ALLOWED_RAM_USAGE", "96"):
+        ds = gdal.Open(vrt_content)
+        with pytest.raises(Exception):
+            ds.ReadAsArray()
diff --git a/frmts/vrt/vrtdataset.h b/frmts/vrt/vrtdataset.h
index bdb148343f1d..c7b44c463bbe 100644
--- a/frmts/vrt/vrtdataset.h
+++ b/frmts/vrt/vrtdataset.h
@@ -665,6 +665,15 @@ class VRTProcessedDataset final : public VRTDataset
 #pragma GCC diagnostic pop
 #endif
 
+  protected:
+    virtual CPLErr IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
+                             int nXSize, int nYSize, void *pData, int nBufXSize,
+                             int nBufYSize, GDALDataType eBufType,
+                             int nBandCount, BANDMAP_TYPE panBandMap,
+                             GSpacing nPixelSpace, GSpacing nLineSpace,
+                             GSpacing nBandSpace,
+                             GDALRasterIOExtraArg *psExtraArg) override;
+
   private:
     friend class VRTProcessedRasterBand;
 
@@ -755,6 +764,12 @@ class VRTProcessedDataset final : public VRTDataset
     //! Value of OutputBands.dataType attribute if m_outputBandDataTypeProvenance = USER_PROVIDED
     GDALDataType m_outputBandDataTypeValue = GDT_Unknown;
 
+    //! Number of temporary bytes we need per output pixel.
+    int m_nWorkingBytesPerPixel = 1;
+
+    //! Value of CPLGetUsablePhysicalRAM() / 10 * 4
+    GIntBig m_nAllowedRAMUsage = 0;
+
     CPLErr Init(const CPLXMLNode *, const char *,
                 const VRTProcessedDataset *poParentDS,
                 GDALDataset *poParentSrcDS, int iOvrLevel);
diff --git a/frmts/vrt/vrtprocesseddataset.cpp b/frmts/vrt/vrtprocesseddataset.cpp
index d8b0875618a4..a428711e7e33 100644
--- a/frmts/vrt/vrtprocesseddataset.cpp
+++ b/frmts/vrt/vrtprocesseddataset.cpp
@@ -593,6 +593,31 @@ CPLErr VRTProcessedDataset::Init(const CPLXMLNode *psTree,
 
     m_oXMLTree.reset(CPLCloneXMLTree(psTree));
 
+    int nLargestInDTSizeTimesBand = 1;
+    int nLargestOutDTSizeTimesBand = 1;
+    for (const auto &oStep : m_aoSteps)
+    {
+        const int nInDTSizeTimesBand =
+            GDALGetDataTypeSizeBytes(oStep.eInDT) * oStep.nInBands;
+        nLargestInDTSizeTimesBand =
+            std::max(nLargestInDTSizeTimesBand, nInDTSizeTimesBand);
+        const int nOutDTSizeTimesBand =
+            GDALGetDataTypeSizeBytes(oStep.eOutDT) * oStep.nOutBands;
+        nLargestOutDTSizeTimesBand =
+            std::max(nLargestOutDTSizeTimesBand, nOutDTSizeTimesBand);
+    }
+    m_nWorkingBytesPerPixel =
+        nLargestInDTSizeTimesBand + nLargestOutDTSizeTimesBand;
+
+    m_nAllowedRAMUsage = CPLGetUsablePhysicalRAM() / 10 * 4;
+    // Only for tests now
+    const char *pszMAX_RAM = "VRT_PROCESSED_DATASET_ALLOWED_RAM_USAGE";
+    if (const char *pszVal = CPLGetConfigOption(pszMAX_RAM, nullptr))
+    {
+        CPL_IGNORE_RET_VAL(
+            CPLParseMemorySize(pszVal, &m_nAllowedRAMUsage, nullptr));
+    }
+
     return CE_None;
 }
 
@@ -1301,14 +1326,14 @@ CPLErr VRTProcessedRasterBand::IReadBlock(int nBlockXOff, int nBlockYOff,
         }
         for (int iY = 0; iY < nBufYSize; ++iY)
         {
-            GDALCopyWords(poVRTDS->m_abyInput.data() +
-                              (iDstBand + static_cast<size_t>(iY) * nBufXSize *
-                                              nOutBands) *
-                                  nLastDTSize,
-                          eLastDT, nLastDTSize * nOutBands,
-                          pDst +
-                              static_cast<size_t>(iY) * nBlockXSize * nDTSize,
-                          eDataType, nDTSize, nBufXSize);
+            GDALCopyWords64(poVRTDS->m_abyInput.data() +
+                                (iDstBand + static_cast<size_t>(iY) *
+                                                nBufXSize * nOutBands) *
+                                    nLastDTSize,
+                            eLastDT, nLastDTSize * nOutBands,
+                            pDst +
+                                static_cast<size_t>(iY) * nBlockXSize * nDTSize,
+                            eDataType, nDTSize, nBufXSize);
         }
         if (poBlock)
             poBlock->DropLock();
@@ -1317,6 +1342,157 @@ CPLErr VRTProcessedRasterBand::IReadBlock(int nBlockXOff, int nBlockYOff,
     return CE_None;
 }
 
+/************************************************************************/
+/*                VRTProcessedDataset::IRasterIO()                      */
+/************************************************************************/
+
+CPLErr VRTProcessedDataset::IRasterIO(
+    GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize,
+    void *pData, int nBufXSize, int nBufYSize, GDALDataType eBufType,
+    int nBandCount, BANDMAP_TYPE panBandMap, GSpacing nPixelSpace,
+    GSpacing nLineSpace, GSpacing nBandSpace, GDALRasterIOExtraArg *psExtraArg)
+{
+    // Try to pass the request to the most appropriate overview dataset.
+    if (nBufXSize < nXSize && nBufYSize < nYSize)
+    {
+        int bTried = FALSE;
+        const CPLErr eErr = TryOverviewRasterIO(
+            eRWFlag, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize, nBufYSize,
+            eBufType, nBandCount, panBandMap, nPixelSpace, nLineSpace,
+            nBandSpace, psExtraArg, &bTried);
+        if (bTried)
+            return eErr;
+    }
+
+    // Optimize reading of all bands at nominal resolution for BIP-like or
+    // BSQ-like buffer spacing.
+    if (eRWFlag == GF_Read && nXSize == nBufXSize && nYSize == nBufYSize &&
+        nBandCount == nBands)
+    {
+        const auto IsSequentialBandMap = [panBandMap, nBandCount]()
+        {
+            for (int i = 0; i < nBandCount; ++i)
+            {
+                if (panBandMap[i] != i + 1)
+                {
+                    return false;
+                }
+            }
+            return true;
+        };
+
+        const int nBufTypeSize = GDALGetDataTypeSizeBytes(eBufType);
+        const bool bIsBIPLike =
+            nBandSpace == nBufTypeSize && nPixelSpace == nBandSpace * nBands &&
+            nLineSpace >= nPixelSpace * nBufXSize && IsSequentialBandMap();
+        const bool bIsBSQLike = nPixelSpace == nBufTypeSize &&
+                                nLineSpace >= nPixelSpace * nBufXSize &&
+                                nBandSpace >= nLineSpace * nBufYSize &&
+                                IsSequentialBandMap();
+        if (bIsBIPLike || bIsBSQLike)
+        {
+            GByte *pabyData = static_cast<GByte *>(pData);
+            // If acquiring the region of interest in a single time is going
+            // to consume too much RAM, split in halves.
+            if (m_nAllowedRAMUsage > 0 &&
+                static_cast<GIntBig>(nBufXSize) * nBufYSize >
+                    m_nAllowedRAMUsage / m_nWorkingBytesPerPixel)
+            {
+                if ((nBufXSize == nRasterXSize || nBufYSize >= nBufXSize) &&
+                    nBufYSize >= 2)
+                {
+                    GDALRasterIOExtraArg sArg;
+                    INIT_RASTERIO_EXTRA_ARG(sArg);
+                    const int nHalfHeight = nBufYSize / 2;
+                    if (IRasterIO(eRWFlag, nXOff, nYOff, nBufXSize, nHalfHeight,
+                                  pabyData, nBufXSize, nHalfHeight, eBufType,
+                                  nBandCount, panBandMap, nPixelSpace,
+                                  nLineSpace, nBandSpace, &sArg) == CE_None &&
+                        IRasterIO(eRWFlag, nXOff, nYOff + nHalfHeight,
+                                  nBufXSize, nBufYSize - nHalfHeight,
+                                  pabyData + nHalfHeight * nLineSpace,
+                                  nBufXSize, nBufYSize - nHalfHeight, eBufType,
+                                  nBandCount, panBandMap, nPixelSpace,
+                                  nLineSpace, nBandSpace, &sArg) == CE_None)
+                    {
+                        return CE_None;
+                    }
+                    else
+                    {
+                        return CE_Failure;
+                    }
+                }
+                else if (nBufXSize >= 2)
+                {
+                    GDALRasterIOExtraArg sArg;
+                    INIT_RASTERIO_EXTRA_ARG(sArg);
+                    const int nHalfWidth = nBufXSize / 2;
+                    if (IRasterIO(eRWFlag, nXOff, nYOff, nHalfWidth, nBufYSize,
+                                  pabyData, nHalfWidth, nBufYSize, eBufType,
+                                  nBandCount, panBandMap, nPixelSpace,
+                                  nLineSpace, nBandSpace, &sArg) == CE_None &&
+                        IRasterIO(eRWFlag, nXOff + nHalfWidth, nYOff,
+                                  nBufXSize - nHalfWidth, nBufYSize,
+                                  pabyData + nHalfWidth * nPixelSpace,
+                                  nBufXSize - nHalfWidth, nBufYSize, eBufType,
+                                  nBandCount, panBandMap, nPixelSpace,
+                                  nLineSpace, nBandSpace, &sArg) == CE_None)
+                    {
+                        return CE_None;
+                    }
+                    else
+                    {
+                        return CE_Failure;
+                    }
+                }
+            }
+
+            if (!ProcessRegion(nXOff, nYOff, nBufXSize, nBufYSize))
+            {
+                return CE_Failure;
+            }
+            const auto eLastDT = m_aoSteps.back().eOutDT;
+            const int nLastDTSize = GDALGetDataTypeSizeBytes(eLastDT);
+            if (bIsBIPLike)
+            {
+                for (int iY = 0; iY < nBufYSize; ++iY)
+                {
+                    GDALCopyWords64(
+                        m_abyInput.data() + static_cast<size_t>(iY) * nBands *
+                                                nBufXSize * nLastDTSize,
+                        eLastDT, nLastDTSize, pabyData + iY * nLineSpace,
+                        eBufType, GDALGetDataTypeSizeBytes(eBufType),
+                        static_cast<size_t>(nBufXSize) * nBands);
+                }
+            }
+            else
+            {
+                CPLAssert(bIsBSQLike);
+                for (int iBand = 0; iBand < nBands; ++iBand)
+                {
+                    for (int iY = 0; iY < nBufYSize; ++iY)
+                    {
+                        GDALCopyWords64(
+                            m_abyInput.data() +
+                                (static_cast<size_t>(iY) * nBands * nBufXSize +
+                                 iBand) *
+                                    nLastDTSize,
+                            eLastDT, nLastDTSize * nBands,
+                            pabyData + iBand * nBandSpace + iY * nLineSpace,
+                            eBufType, nBufTypeSize, nBufXSize);
+                    }
+                }
+            }
+            return CE_None;
+        }
+    }
+
+    return VRTDataset::IRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize, pData,
+                                 nBufXSize, nBufYSize, eBufType, nBandCount,
+                                 panBandMap, nPixelSpace, nLineSpace,
+                                 nBandSpace, psExtraArg);
+}
+
 /*! @endcond */
 
 /************************************************************************/

From 8043ece3d4f1960e9536cd2c24c971ab6c24b087 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Sun, 5 Jan 2025 21:44:58 +0100
Subject: [PATCH 31/40] VRTProcessedDataset::IRasterIO(): implement progress
 report

---
 frmts/vrt/vrtdataset.h            |   3 +-
 frmts/vrt/vrtprocesseddataset.cpp | 138 ++++++++++++++++++++++--------
 2 files changed, 102 insertions(+), 39 deletions(-)

diff --git a/frmts/vrt/vrtdataset.h b/frmts/vrt/vrtdataset.h
index c7b44c463bbe..50fbac8e0a46 100644
--- a/frmts/vrt/vrtdataset.h
+++ b/frmts/vrt/vrtdataset.h
@@ -778,7 +778,8 @@ class VRTProcessedDataset final : public VRTDataset
                    GDALDataType &eCurrentDT, int &nCurrentBandCount,
                    std::vector<double> &adfInNoData,
                    std::vector<double> &adfOutNoData);
-    bool ProcessRegion(int nXOff, int nYOff, int nBufXSize, int nBufYSize);
+    bool ProcessRegion(int nXOff, int nYOff, int nBufXSize, int nBufYSize,
+                       GDALProgressFunc pfnProgress, void *pProgressData);
 };
 
 /************************************************************************/
diff --git a/frmts/vrt/vrtprocesseddataset.cpp b/frmts/vrt/vrtprocesseddataset.cpp
index a428711e7e33..0a9249b4afed 100644
--- a/frmts/vrt/vrtprocesseddataset.cpp
+++ b/frmts/vrt/vrtprocesseddataset.cpp
@@ -1060,7 +1060,9 @@ void VRTProcessedDataset::GetBlockSize(int *pnBlockXSize,
  * The output is stored in m_abyInput in a pixel-interleaved way.
  */
 bool VRTProcessedDataset::ProcessRegion(int nXOff, int nYOff, int nBufXSize,
-                                        int nBufYSize)
+                                        int nBufYSize,
+                                        GDALProgressFunc pfnProgress,
+                                        void *pProgressData)
 {
 
     CPLAssert(!m_aoSteps.empty());
@@ -1108,15 +1110,24 @@ bool VRTProcessedDataset::ProcessRegion(int nXOff, int nYOff, int nBufXSize,
             return false;
         }
 
+        GDALRasterIOExtraArg sArg;
+        INIT_RASTERIO_EXTRA_ARG(sArg);
+        sArg.pfnProgress = GDALScaledProgress;
+        sArg.pProgressData =
+            GDALCreateScaledProgress(0, 0.5, pfnProgress, pProgressData);
+        if (sArg.pProgressData == nullptr)
+            sArg.pfnProgress = nullptr;
+
         CPLDebugOnly("VRT", "ProcessRegion(): start RasterIO()");
-        if (m_poSrcDS->RasterIO(GF_Read, nXOff, nYOff, nBufXSize, nBufYSize,
+        const bool bOK =
+            m_poSrcDS->RasterIO(GF_Read, nXOff, nYOff, nBufXSize, nBufYSize,
                                 abyInput.data(), nBufXSize, nBufYSize, eSrcDT,
                                 nFirstBandCount, nullptr, 0, 0, 0,
-                                nullptr) != CE_None)
-        {
-            return false;
-        }
+                                &sArg) == CE_None;
         CPLDebugOnly("VRT", "ProcessRegion(): end RasterIO()");
+        GDALDestroyScaledProgress(sArg.pProgressData);
+        if (!bOK)
+            return false;
 
         CPLDebugOnly("VRT", "ProcessRegion(): start GDALTranspose2D()");
         GDALTranspose2D(abyInput.data(), eSrcDT, abyOutput.data(), eFirstDT,
@@ -1140,16 +1151,26 @@ bool VRTProcessedDataset::ProcessRegion(int nXOff, int nYOff, int nBufXSize,
             return false;
         }
 
-        if (m_poSrcDS->RasterIO(
+        GDALRasterIOExtraArg sArg;
+        INIT_RASTERIO_EXTRA_ARG(sArg);
+        sArg.pfnProgress = GDALScaledProgress;
+        sArg.pProgressData =
+            GDALCreateScaledProgress(0, 0.5, pfnProgress, pProgressData);
+        if (sArg.pProgressData == nullptr)
+            sArg.pfnProgress = nullptr;
+
+        const bool bOK =
+            m_poSrcDS->RasterIO(
                 GF_Read, nXOff, nYOff, nBufXSize, nBufYSize, abyInput.data(),
                 nBufXSize, nBufYSize, eFirstDT, nFirstBandCount, nullptr,
                 static_cast<GSpacing>(nFirstDTSize) * nFirstBandCount,
                 static_cast<GSpacing>(nFirstDTSize) * nFirstBandCount *
                     nBufXSize,
-                nFirstDTSize, nullptr) != CE_None)
-        {
+                nFirstDTSize, &sArg) == CE_None;
+
+        GDALDestroyScaledProgress(sArg.pProgressData);
+        if (!bOK)
             return false;
-        }
     }
 
     const double dfSrcXOff = nXOff;
@@ -1170,6 +1191,8 @@ bool VRTProcessedDataset::ProcessRegion(int nXOff, int nYOff, int nBufXSize,
 
     GDALDataType eLastDT = eFirstDT;
     const auto &oMapFunctions = GetGlobalMapProcessedDatasetFunc();
+
+    int iStep = 0;
     for (const auto &oStep : m_aoSteps)
     {
         const auto oIterFunc = oMapFunctions.find(oStep.osAlgorithm);
@@ -1226,6 +1249,12 @@ bool VRTProcessedDataset::ProcessRegion(int nXOff, int nYOff, int nBufXSize,
 
         std::swap(abyInput, abyOutput);
         eLastDT = oStep.eOutDT;
+
+        ++iStep;
+        if (pfnProgress &&
+            !pfnProgress(0.5 + 0.5 * iStep / static_cast<int>(m_aoSteps.size()),
+                         "", pProgressData))
+            return false;
     }
 
     return true;
@@ -1289,7 +1318,8 @@ CPLErr VRTProcessedRasterBand::IReadBlock(int nBlockXOff, int nBlockYOff,
 
     const int nXPixelOff = nBlockXOff * nBlockXSize;
     const int nYPixelOff = nBlockYOff * nBlockYSize;
-    if (!poVRTDS->ProcessRegion(nXPixelOff, nYPixelOff, nBufXSize, nBufYSize))
+    if (!poVRTDS->ProcessRegion(nXPixelOff, nYPixelOff, nBufXSize, nBufYSize,
+                                nullptr, nullptr))
     {
         return CE_Failure;
     }
@@ -1404,50 +1434,82 @@ CPLErr VRTProcessedDataset::IRasterIO(
                     GDALRasterIOExtraArg sArg;
                     INIT_RASTERIO_EXTRA_ARG(sArg);
                     const int nHalfHeight = nBufYSize / 2;
-                    if (IRasterIO(eRWFlag, nXOff, nYOff, nBufXSize, nHalfHeight,
+
+                    sArg.pfnProgress = GDALScaledProgress;
+                    sArg.pProgressData = GDALCreateScaledProgress(
+                        0, 0.5, psExtraArg->pfnProgress,
+                        psExtraArg->pProgressData);
+                    if (sArg.pProgressData == nullptr)
+                        sArg.pfnProgress = nullptr;
+                    bool bOK =
+                        IRasterIO(eRWFlag, nXOff, nYOff, nBufXSize, nHalfHeight,
                                   pabyData, nBufXSize, nHalfHeight, eBufType,
                                   nBandCount, panBandMap, nPixelSpace,
-                                  nLineSpace, nBandSpace, &sArg) == CE_None &&
-                        IRasterIO(eRWFlag, nXOff, nYOff + nHalfHeight,
-                                  nBufXSize, nBufYSize - nHalfHeight,
-                                  pabyData + nHalfHeight * nLineSpace,
-                                  nBufXSize, nBufYSize - nHalfHeight, eBufType,
-                                  nBandCount, panBandMap, nPixelSpace,
-                                  nLineSpace, nBandSpace, &sArg) == CE_None)
-                    {
-                        return CE_None;
-                    }
-                    else
+                                  nLineSpace, nBandSpace, &sArg) == CE_None;
+                    GDALDestroyScaledProgress(sArg.pProgressData);
+
+                    if (bOK)
                     {
-                        return CE_Failure;
+                        sArg.pfnProgress = GDALScaledProgress;
+                        sArg.pProgressData = GDALCreateScaledProgress(
+                            0.5, 1, psExtraArg->pfnProgress,
+                            psExtraArg->pProgressData);
+                        if (sArg.pProgressData == nullptr)
+                            sArg.pfnProgress = nullptr;
+                        bOK = IRasterIO(eRWFlag, nXOff, nYOff + nHalfHeight,
+                                        nBufXSize, nBufYSize - nHalfHeight,
+                                        pabyData + nHalfHeight * nLineSpace,
+                                        nBufXSize, nBufYSize - nHalfHeight,
+                                        eBufType, nBandCount, panBandMap,
+                                        nPixelSpace, nLineSpace, nBandSpace,
+                                        &sArg) == CE_None;
+                        GDALDestroyScaledProgress(sArg.pProgressData);
                     }
+                    return bOK ? CE_None : CE_Failure;
                 }
                 else if (nBufXSize >= 2)
                 {
                     GDALRasterIOExtraArg sArg;
                     INIT_RASTERIO_EXTRA_ARG(sArg);
                     const int nHalfWidth = nBufXSize / 2;
-                    if (IRasterIO(eRWFlag, nXOff, nYOff, nHalfWidth, nBufYSize,
+
+                    sArg.pfnProgress = GDALScaledProgress;
+                    sArg.pProgressData = GDALCreateScaledProgress(
+                        0, 0.5, psExtraArg->pfnProgress,
+                        psExtraArg->pProgressData);
+                    if (sArg.pProgressData == nullptr)
+                        sArg.pfnProgress = nullptr;
+                    bool bOK =
+                        IRasterIO(eRWFlag, nXOff, nYOff, nHalfWidth, nBufYSize,
                                   pabyData, nHalfWidth, nBufYSize, eBufType,
                                   nBandCount, panBandMap, nPixelSpace,
-                                  nLineSpace, nBandSpace, &sArg) == CE_None &&
-                        IRasterIO(eRWFlag, nXOff + nHalfWidth, nYOff,
-                                  nBufXSize - nHalfWidth, nBufYSize,
-                                  pabyData + nHalfWidth * nPixelSpace,
-                                  nBufXSize - nHalfWidth, nBufYSize, eBufType,
-                                  nBandCount, panBandMap, nPixelSpace,
-                                  nLineSpace, nBandSpace, &sArg) == CE_None)
-                    {
-                        return CE_None;
-                    }
-                    else
+                                  nLineSpace, nBandSpace, &sArg) == CE_None;
+                    GDALDestroyScaledProgress(sArg.pProgressData);
+
+                    if (bOK)
                     {
-                        return CE_Failure;
+                        sArg.pfnProgress = GDALScaledProgress;
+                        sArg.pProgressData = GDALCreateScaledProgress(
+                            0.5, 1, psExtraArg->pfnProgress,
+                            psExtraArg->pProgressData);
+                        if (sArg.pProgressData == nullptr)
+                            sArg.pfnProgress = nullptr;
+                        bOK = IRasterIO(eRWFlag, nXOff + nHalfWidth, nYOff,
+                                        nBufXSize - nHalfWidth, nBufYSize,
+                                        pabyData + nHalfWidth * nPixelSpace,
+                                        nBufXSize - nHalfWidth, nBufYSize,
+                                        eBufType, nBandCount, panBandMap,
+                                        nPixelSpace, nLineSpace, nBandSpace,
+                                        &sArg) == CE_None;
+                        GDALDestroyScaledProgress(sArg.pProgressData);
                     }
+                    return bOK ? CE_None : CE_Failure;
                 }
             }
 
-            if (!ProcessRegion(nXOff, nYOff, nBufXSize, nBufYSize))
+            if (!ProcessRegion(nXOff, nYOff, nBufXSize, nBufYSize,
+                               psExtraArg->pfnProgress,
+                               psExtraArg->pProgressData))
             {
                 return CE_Failure;
             }

From 44ff97a0a4165e0552c1bdb333620ad5357163d1 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Mon, 6 Jan 2025 21:24:25 +0100
Subject: [PATCH 32/40] vrtprocesseddataset.cpp: factor code common to 2 recent
 pull requests

---
 autotest/gdrivers/vrtprocesseddataset.py |  1 +
 frmts/vrt/vrtprocesseddataset.cpp        | 70 +++++++++---------------
 2 files changed, 27 insertions(+), 44 deletions(-)

diff --git a/autotest/gdrivers/vrtprocesseddataset.py b/autotest/gdrivers/vrtprocesseddataset.py
index 63ff0749dde5..633f2158a654 100755
--- a/autotest/gdrivers/vrtprocesseddataset.py
+++ b/autotest/gdrivers/vrtprocesseddataset.py
@@ -1514,5 +1514,6 @@ def test_vrtprocesseddataset_RasterIO(tmp_vsimem):
 
     with gdal.config_option("VRT_PROCESSED_DATASET_ALLOWED_RAM_USAGE", "96"):
         ds = gdal.Open(vrt_content)
+        assert ds.GetRasterBand(1).GetBlockSize() == [1, 1]
         with pytest.raises(Exception):
             ds.ReadAsArray()
diff --git a/frmts/vrt/vrtprocesseddataset.cpp b/frmts/vrt/vrtprocesseddataset.cpp
index d6c8d7ce5a7d..318da09023aa 100644
--- a/frmts/vrt/vrtprocesseddataset.cpp
+++ b/frmts/vrt/vrtprocesseddataset.cpp
@@ -538,32 +538,39 @@ CPLErr VRTProcessedDataset::Init(const CPLXMLNode *psTree,
         return CE_Failure;
     }
 
+    int nLargestInDTSizeTimesBand = 1;
+    int nLargestOutDTSizeTimesBand = 1;
+    for (const auto &oStep : m_aoSteps)
+    {
+        const int nInDTSizeTimesBand =
+            GDALGetDataTypeSizeBytes(oStep.eInDT) * oStep.nInBands;
+        nLargestInDTSizeTimesBand =
+            std::max(nLargestInDTSizeTimesBand, nInDTSizeTimesBand);
+        const int nOutDTSizeTimesBand =
+            GDALGetDataTypeSizeBytes(oStep.eOutDT) * oStep.nOutBands;
+        nLargestOutDTSizeTimesBand =
+            std::max(nLargestOutDTSizeTimesBand, nOutDTSizeTimesBand);
+    }
+    m_nWorkingBytesPerPixel =
+        nLargestInDTSizeTimesBand + nLargestOutDTSizeTimesBand;
+
     // Use only up to 40% of RAM to acquire source bands and generate the output
     // buffer.
-    const auto nMaxMemAllowed = CPLGetUsablePhysicalRAM() / 10 * 4;
-    if (nMaxMemAllowed > 0)
+    m_nAllowedRAMUsage = CPLGetUsablePhysicalRAM() / 10 * 4;
+    // Only for tests now
+    const char *pszMAX_RAM = "VRT_PROCESSED_DATASET_ALLOWED_RAM_USAGE";
+    if (const char *pszVal = CPLGetConfigOption(pszMAX_RAM, nullptr))
     {
-        int nLargestInDTSizeTimesBand = 1;
-        int nLargestOutDTSizeTimesBand = 1;
-        for (const auto &oStep : m_aoSteps)
-        {
-            const int nInDTSizeTimesBand =
-                GDALGetDataTypeSizeBytes(oStep.eInDT) * oStep.nInBands;
-            nLargestInDTSizeTimesBand =
-                std::max(nLargestInDTSizeTimesBand, nInDTSizeTimesBand);
-            const int nOutDTSizeTimesBand =
-                GDALGetDataTypeSizeBytes(oStep.eOutDT) * oStep.nOutBands;
-            nLargestOutDTSizeTimesBand =
-                std::max(nLargestOutDTSizeTimesBand, nOutDTSizeTimesBand);
-        }
-
-        const int nPerPixelSize =
-            nLargestInDTSizeTimesBand + nLargestOutDTSizeTimesBand;
+        CPL_IGNORE_RET_VAL(
+            CPLParseMemorySize(pszVal, &m_nAllowedRAMUsage, nullptr));
+    }
 
+    if (m_nAllowedRAMUsage > 0)
+    {
         bool bBlockSizeModified = false;
         while ((m_nBlockXSize >= 2 || m_nBlockYSize >= 2) &&
                static_cast<GIntBig>(m_nBlockXSize) * m_nBlockYSize >
-                   nMaxMemAllowed / nPerPixelSize)
+                   m_nAllowedRAMUsage / m_nWorkingBytesPerPixel)
         {
             if ((m_nBlockXSize == nRasterXSize ||
                  m_nBlockYSize >= m_nBlockXSize) &&
@@ -670,31 +677,6 @@ CPLErr VRTProcessedDataset::Init(const CPLXMLNode *psTree,
 
     m_oXMLTree.reset(CPLCloneXMLTree(psTree));
 
-    int nLargestInDTSizeTimesBand = 1;
-    int nLargestOutDTSizeTimesBand = 1;
-    for (const auto &oStep : m_aoSteps)
-    {
-        const int nInDTSizeTimesBand =
-            GDALGetDataTypeSizeBytes(oStep.eInDT) * oStep.nInBands;
-        nLargestInDTSizeTimesBand =
-            std::max(nLargestInDTSizeTimesBand, nInDTSizeTimesBand);
-        const int nOutDTSizeTimesBand =
-            GDALGetDataTypeSizeBytes(oStep.eOutDT) * oStep.nOutBands;
-        nLargestOutDTSizeTimesBand =
-            std::max(nLargestOutDTSizeTimesBand, nOutDTSizeTimesBand);
-    }
-    m_nWorkingBytesPerPixel =
-        nLargestInDTSizeTimesBand + nLargestOutDTSizeTimesBand;
-
-    m_nAllowedRAMUsage = CPLGetUsablePhysicalRAM() / 10 * 4;
-    // Only for tests now
-    const char *pszMAX_RAM = "VRT_PROCESSED_DATASET_ALLOWED_RAM_USAGE";
-    if (const char *pszVal = CPLGetConfigOption(pszMAX_RAM, nullptr))
-    {
-        CPL_IGNORE_RET_VAL(
-            CPLParseMemorySize(pszVal, &m_nAllowedRAMUsage, nullptr));
-    }
-
     return CE_None;
 }
 

From 890c4696c437709c7a5da1960ae16cfb33f9b88c Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Mon, 6 Jan 2025 22:14:56 +0100
Subject: [PATCH 33/40] fuzzers: add a fuzzer for LIBERTIFF driver

Fixes #11523
---
 fuzzers/CMakeLists.txt              | 10 ++++++++++
 fuzzers/build_google_oss_fuzzers.sh |  2 ++
 fuzzers/gdal_fuzzer.cpp             | 10 +++++++++-
 3 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/fuzzers/CMakeLists.txt b/fuzzers/CMakeLists.txt
index 5cf1b6dc73bf..22347958d5d9 100644
--- a/fuzzers/CMakeLists.txt
+++ b/fuzzers/CMakeLists.txt
@@ -124,6 +124,16 @@ build_gdal_specialized_fuzzer(gdal_sdts GDALRegister_SDTS "/vsimem/test.tar" "/v
 build_gdal_specialized_fuzzer(gdal_vrt GDALAllRegister "/vsimem/test.tar" "/vsitar//vsimem/test.tar/test.vrt")
 build_gdal_specialized_fuzzer(ers GDALRegister_ERS "/vsimem/test.tar" "/vsitar//vsimem/test.tar/test.ers")
 
+build_fuzzer(
+    NAME
+    libertiff_fuzzer
+    SOURCES
+    gdal_fuzzer.cpp
+    DEFINITIONS
+    -DREGISTER_FUNC=GDALRegister_LIBERTIFF
+    -DDRIVER_NAME="LIBERTIFF"
+)
+
 build_fuzzer(
   NAME
   gdal_filesystem_fuzzer
diff --git a/fuzzers/build_google_oss_fuzzers.sh b/fuzzers/build_google_oss_fuzzers.sh
index ad0b2c2a863c..3035cae6f5db 100755
--- a/fuzzers/build_google_oss_fuzzers.sh
+++ b/fuzzers/build_google_oss_fuzzers.sh
@@ -69,6 +69,8 @@ build_gdal_specialized_fuzzer()
 
 build_fuzzer gtiff_mmap $(dirname $0)/gdal_fuzzer.cpp -DREGISTER_FUNC=GDALRegister_GTiff -DGTIFF_USE_MMAP
 
+build_fuzzer libertiff $(dirname $0)/gdal_fuzzer.cpp -DREGISTER_FUNC=GDALRegister_LIBERTIFF -DDRIVER_NAME="\"LIBERTIFF\""
+
 fuzzerFiles="$(dirname $0)/*.cpp"
 for F in $fuzzerFiles; do
     if test $F != "$(dirname $0)/fuzzingengine.cpp"; then
diff --git a/fuzzers/gdal_fuzzer.cpp b/fuzzers/gdal_fuzzer.cpp
index 495862edd992..ef66a37c8c17 100644
--- a/fuzzers/gdal_fuzzer.cpp
+++ b/fuzzers/gdal_fuzzer.cpp
@@ -213,7 +213,15 @@ int LLVMFuzzerTestOneInput(const uint8_t *buf, size_t len)
 #else
     const char *pszGDALFilename = GDAL_FILENAME;
 #endif
-    GDALDatasetH hDS = GDALOpen(pszGDALFilename, GA_ReadOnly);
+
+#ifdef DRIVER_NAME
+    const char *const apszAllowedDrivers[] = {DRIVER_NAME, nullptr};
+#else
+    const char *const *apszAllowedDrivers = nullptr;
+#endif
+
+    GDALDatasetH hDS = GDALOpenEx(pszGDALFilename, GDAL_OF_RASTER,
+                                  apszAllowedDrivers, nullptr, nullptr);
     if (hDS)
     {
         const int nTotalBands = GDALGetRasterCount(hDS);

From 5ebd9bf1b82872ed647df07f711c9fa377960294 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Mon, 6 Jan 2025 23:47:44 +0100
Subject: [PATCH 34/40] docker: copy bash completion files [ci skip]

---
 docker/alpine-normal/Dockerfile | 1 +
 docker/alpine-small/Dockerfile  | 1 +
 docker/ubuntu-full/Dockerfile   | 1 +
 docker/ubuntu-small/Dockerfile  | 1 +
 4 files changed, 4 insertions(+)

diff --git a/docker/alpine-normal/Dockerfile b/docker/alpine-normal/Dockerfile
index 0582d83d297c..5be0a49898a1 100644
--- a/docker/alpine-normal/Dockerfile
+++ b/docker/alpine-normal/Dockerfile
@@ -413,6 +413,7 @@ COPY --from=builder  /build_proj/usr/include/ /usr/include/
 COPY --from=builder  /build_proj/usr/bin/ /usr/bin/
 COPY --from=builder  /build_proj/usr/lib/ /usr/lib/
 
+COPY --from=builder  /build/usr/share/bash-completion/ /usr/share/bash-completion/
 COPY --from=builder  /build/usr/share/gdal/ /usr/share/gdal/
 COPY --from=builder  /build/usr/include/ /usr/include/
 COPY --from=builder  /build_gdal_python/usr/ /usr/
diff --git a/docker/alpine-small/Dockerfile b/docker/alpine-small/Dockerfile
index 1add1c3d1c01..bafacae7831f 100644
--- a/docker/alpine-small/Dockerfile
+++ b/docker/alpine-small/Dockerfile
@@ -191,6 +191,7 @@ COPY --from=builder  /build_proj/usr/include/ /usr/include/
 COPY --from=builder  /build_proj/usr/bin/ /usr/bin/
 COPY --from=builder  /build_proj/usr/lib/ /usr/lib/
 
+COPY --from=builder  /build/usr/share/bash-completion/ /usr/share/bash-completion/
 COPY --from=builder  /build/usr/share/gdal/ /usr/share/gdal/
 COPY --from=builder  /build/usr/include/ /usr/include/
 COPY --from=builder  /build_gdal_version_changing/usr/ /usr/
diff --git a/docker/ubuntu-full/Dockerfile b/docker/ubuntu-full/Dockerfile
index e0d9383ac262..5b65e42ef6b3 100644
--- a/docker/ubuntu-full/Dockerfile
+++ b/docker/ubuntu-full/Dockerfile
@@ -606,6 +606,7 @@ COPY --from=builder  /build${PROJ_INSTALL_PREFIX}/include/ ${PROJ_INSTALL_PREFIX
 COPY --from=builder  /build${PROJ_INSTALL_PREFIX}/bin/ ${PROJ_INSTALL_PREFIX}/bin/
 COPY --from=builder  /build${PROJ_INSTALL_PREFIX}/lib/ ${PROJ_INSTALL_PREFIX}/lib/
 
+COPY --from=builder  /build/usr/share/bash-completion/ /usr/share/bash-completion/
 COPY --from=builder  /build/usr/share/java /usr/share/java
 COPY --from=builder  /build/usr/share/gdal/ /usr/share/gdal/
 COPY --from=builder  /build/usr/include/ /usr/include/
diff --git a/docker/ubuntu-small/Dockerfile b/docker/ubuntu-small/Dockerfile
index 65cf4fd17b3a..fe511e32c7cd 100644
--- a/docker/ubuntu-small/Dockerfile
+++ b/docker/ubuntu-small/Dockerfile
@@ -258,6 +258,7 @@ COPY --from=builder  /build${PROJ_INSTALL_PREFIX}/include/ ${PROJ_INSTALL_PREFIX
 COPY --from=builder  /build${PROJ_INSTALL_PREFIX}/bin/ ${PROJ_INSTALL_PREFIX}/bin/
 COPY --from=builder  /build${PROJ_INSTALL_PREFIX}/lib/ ${PROJ_INSTALL_PREFIX}/lib/
 
+COPY --from=builder  /build/usr/share/bash-completion/ /usr/share/bash-completion/
 COPY --from=builder  /build/usr/share/gdal/ /usr/share/gdal/
 COPY --from=builder  /build/usr/include/ /usr/include/
 COPY --from=builder  /build_gdal_python/usr/ /usr/

From d32bf3316cc3df9ffe38b758b7957583b2d5ff38 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Tue, 7 Jan 2025 00:02:36 +0100
Subject: [PATCH 35/40] scripts/install_bash_completions.cmake.in: add gdal CLI
 [ci skip]

---
 scripts/install_bash_completions.cmake.in | 1 +
 1 file changed, 1 insertion(+)

diff --git a/scripts/install_bash_completions.cmake.in b/scripts/install_bash_completions.cmake.in
index 836adcd41519..c13a8bc69c8d 100644
--- a/scripts/install_bash_completions.cmake.in
+++ b/scripts/install_bash_completions.cmake.in
@@ -1,5 +1,6 @@
 # All but gdalinfo
 set(PROGRAMS
+    gdal
     gdal2tiles.py
     gdal2xyz.py
     gdaladdo

From b00a212cd619dfeaf3e0f73bce67329aa27c8663 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Tue, 7 Jan 2025 04:05:26 +0100
Subject: [PATCH 36/40] Use a single namespace for libertiff within LIBERTIFF
 and SNAP_TIFF drivers

---
 frmts/libertiff/libertiffdataset.cpp |  2 +-
 third_party/libertiff/libertiff.hpp  | 69 +++++++++++++---------------
 2 files changed, 34 insertions(+), 37 deletions(-)

diff --git a/frmts/libertiff/libertiffdataset.cpp b/frmts/libertiff/libertiffdataset.cpp
index e9bcf7b75cd7..df1a276877c8 100644
--- a/frmts/libertiff/libertiffdataset.cpp
+++ b/frmts/libertiff/libertiffdataset.cpp
@@ -31,7 +31,7 @@
 #include "gdal_thread_pool.h"
 #include "memdataset.h"
 
-#define LIBERTIFF_NS GDALLibertiffDataset
+#define LIBERTIFF_NS GDAL_libertiff
 #include "libertiff.hpp"
 
 #include "libtiff_codecs.h"
diff --git a/third_party/libertiff/libertiff.hpp b/third_party/libertiff/libertiff.hpp
index e50a8f08c1d0..1ea5e71d085f 100644
--- a/third_party/libertiff/libertiff.hpp
+++ b/third_party/libertiff/libertiff.hpp
@@ -92,25 +92,25 @@ inline bool isHostLittleEndian()
 template <class T> inline T byteSwap(T v);
 
 /** Byte-swap a uint8_t */
-template <> uint8_t byteSwap(uint8_t v)
+template <> inline uint8_t byteSwap(uint8_t v)
 {
     return v;
 }
 
 /** Byte-swap a int8_t */
-template <> int8_t byteSwap(int8_t v)
+template <> inline int8_t byteSwap(int8_t v)
 {
     return v;
 }
 
 /** Byte-swap a uint16_t */
-template <> uint16_t byteSwap(uint16_t v)
+template <> inline uint16_t byteSwap(uint16_t v)
 {
     return uint16_t((v >> 8) | ((v & 0xff) << 8));
 }
 
 /** Byte-swap a int16_t */
-template <> int16_t byteSwap(int16_t v)
+template <> inline int16_t byteSwap(int16_t v)
 {
     uint16_t u;
     LIBERTIFF_STATIC_ASSERT(sizeof(v) == sizeof(u));
@@ -121,14 +121,14 @@ template <> int16_t byteSwap(int16_t v)
 }
 
 /** Byte-swap a uint32_t */
-template <> uint32_t byteSwap(uint32_t v)
+template <> inline uint32_t byteSwap(uint32_t v)
 {
     return (v >> 24) | (((v >> 16) & 0xff) << 8) | (((v >> 8) & 0xff) << 16) |
            ((v & 0xff) << 24);
 }
 
 /** Byte-swap a int32_t */
-template <> int32_t byteSwap(int32_t v)
+template <> inline int32_t byteSwap(int32_t v)
 {
     uint32_t u;
     LIBERTIFF_STATIC_ASSERT(sizeof(v) == sizeof(u));
@@ -139,14 +139,14 @@ template <> int32_t byteSwap(int32_t v)
 }
 
 /** Byte-swap a uint64_t */
-template <> uint64_t byteSwap(uint64_t v)
+template <> inline uint64_t byteSwap(uint64_t v)
 {
     return (uint64_t(byteSwap(uint32_t(v & ~(0U)))) << 32) |
            byteSwap(uint32_t(v >> 32));
 }
 
 /** Byte-swap a int64_t */
-template <> int64_t byteSwap(int64_t v)
+template <> inline int64_t byteSwap(int64_t v)
 {
     uint64_t u;
     std::memcpy(&u, &v, sizeof(u));
@@ -156,7 +156,7 @@ template <> int64_t byteSwap(int64_t v)
 }
 
 /** Byte-swap a float */
-template <> float byteSwap(float v)
+template <> inline float byteSwap(float v)
 {
     uint32_t u;
     LIBERTIFF_STATIC_ASSERT(sizeof(v) == sizeof(u));
@@ -167,7 +167,7 @@ template <> float byteSwap(float v)
 }
 
 /** Byte-swap a double */
-template <> double byteSwap(double v)
+template <> inline double byteSwap(double v)
 {
     uint64_t u;
     LIBERTIFF_STATIC_ASSERT(sizeof(v) == sizeof(u));
@@ -600,10 +600,7 @@ constexpr PhotometricInterpretationType ITULab = 10;
     case PhotometricInterpretation::x:                                         \
         return #x
 
-const char *photometricInterpretationName(
-    PhotometricInterpretationType photometricInterpretation);
-
-const char *photometricInterpretationName(
+inline const char *photometricInterpretationName(
     PhotometricInterpretationType photometricInterpretation)
 {
     switch (photometricInterpretation)
@@ -833,20 +830,20 @@ inline std::vector<T> readTagAsVectorInternal(const ReadContext &rc,
 }
 
 template <class T>
-std::vector<T> readTagAsVector(const ReadContext &rc, const TagEntry &tag,
-                               bool &ok);
+inline std::vector<T> readTagAsVector(const ReadContext &rc,
+                                      const TagEntry &tag, bool &ok);
 
 template <>
-std::vector<int8_t> readTagAsVector(const ReadContext &rc, const TagEntry &tag,
-                                    bool &ok)
+inline std::vector<int8_t> readTagAsVector(const ReadContext &rc,
+                                           const TagEntry &tag, bool &ok)
 {
     return readTagAsVectorInternal(rc, tag, TagType::SByte,
                                    tag.int8Values.data(), ok);
 }
 
 template <>
-std::vector<uint8_t> readTagAsVector(const ReadContext &rc, const TagEntry &tag,
-                                     bool &ok)
+inline std::vector<uint8_t> readTagAsVector(const ReadContext &rc,
+                                            const TagEntry &tag, bool &ok)
 {
     return readTagAsVectorInternal(
         rc, tag, tag.type == TagType::Undefined ? tag.type : TagType::Byte,
@@ -854,64 +851,64 @@ std::vector<uint8_t> readTagAsVector(const ReadContext &rc, const TagEntry &tag,
 }
 
 template <>
-std::vector<int16_t> readTagAsVector(const ReadContext &rc, const TagEntry &tag,
-                                     bool &ok)
+inline std::vector<int16_t> readTagAsVector(const ReadContext &rc,
+                                            const TagEntry &tag, bool &ok)
 {
     return readTagAsVectorInternal(rc, tag, TagType::SShort,
                                    tag.int16Values.data(), ok);
 }
 
 template <>
-std::vector<uint16_t> readTagAsVector(const ReadContext &rc,
-                                      const TagEntry &tag, bool &ok)
+inline std::vector<uint16_t> readTagAsVector(const ReadContext &rc,
+                                             const TagEntry &tag, bool &ok)
 {
     return readTagAsVectorInternal(rc, tag, TagType::Short,
                                    tag.uint16Values.data(), ok);
 }
 
 template <>
-std::vector<int32_t> readTagAsVector(const ReadContext &rc, const TagEntry &tag,
-                                     bool &ok)
+inline std::vector<int32_t> readTagAsVector(const ReadContext &rc,
+                                            const TagEntry &tag, bool &ok)
 {
     return readTagAsVectorInternal(rc, tag, TagType::SLong,
                                    tag.int32Values.data(), ok);
 }
 
 template <>
-std::vector<uint32_t> readTagAsVector(const ReadContext &rc,
-                                      const TagEntry &tag, bool &ok)
+inline std::vector<uint32_t> readTagAsVector(const ReadContext &rc,
+                                             const TagEntry &tag, bool &ok)
 {
     return readTagAsVectorInternal(rc, tag, TagType::Long,
                                    tag.uint32Values.data(), ok);
 }
 
 template <>
-std::vector<int64_t> readTagAsVector(const ReadContext &rc, const TagEntry &tag,
-                                     bool &ok)
+inline std::vector<int64_t> readTagAsVector(const ReadContext &rc,
+                                            const TagEntry &tag, bool &ok)
 {
     return readTagAsVectorInternal(rc, tag, TagType::SLong8,
                                    tag.int64Values.data(), ok);
 }
 
 template <>
-std::vector<uint64_t> readTagAsVector(const ReadContext &rc,
-                                      const TagEntry &tag, bool &ok)
+inline std::vector<uint64_t> readTagAsVector(const ReadContext &rc,
+                                             const TagEntry &tag, bool &ok)
 {
     return readTagAsVectorInternal(rc, tag, TagType::Long8,
                                    tag.uint64Values.data(), ok);
 }
 
 template <>
-std::vector<float> readTagAsVector(const ReadContext &rc, const TagEntry &tag,
-                                   bool &ok)
+inline std::vector<float> readTagAsVector(const ReadContext &rc,
+                                          const TagEntry &tag, bool &ok)
 {
     return readTagAsVectorInternal(rc, tag, TagType::Float,
                                    tag.float32Values.data(), ok);
 }
 
 template <>
-std::vector<double> readTagAsVector(const ReadContext &rc, const TagEntry &tag,
-                                    bool &ok)
+inline std::vector<double> readTagAsVector(const ReadContext &rc,
+                                           const TagEntry &tag, bool &ok)
 {
     return readTagAsVectorInternal(rc, tag, TagType::Double,
                                    tag.float64Values.data(), ok);

From b5c3b1edce066501e4ee517ba3f31918ffde4d31 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Tue, 7 Jan 2025 04:05:53 +0100
Subject: [PATCH 37/40] Move GDALTranspose2D templates into rasterio.cpp

---
 gcore/gdal_priv_templates.hpp | 151 ----------------------------------
 gcore/rasterio.cpp            | 151 ++++++++++++++++++++++++++++++++++
 2 files changed, 151 insertions(+), 151 deletions(-)

diff --git a/gcore/gdal_priv_templates.hpp b/gcore/gdal_priv_templates.hpp
index e9ca6f828272..0622ee2a76c9 100644
--- a/gcore/gdal_priv_templates.hpp
+++ b/gcore/gdal_priv_templates.hpp
@@ -778,155 +778,4 @@ inline void GDALCopy4Words(const double *pValueIn, float *const pValueOut)
 
 #endif  //  defined(__x86_64) || defined(_M_X64)
 
-/************************************************************************/
-/*                    GDALTranspose2DSingleToSingle()                   */
-/************************************************************************/
-/**
- * Transpose a 2D array of non-complex values, in a efficient (cache-oblivious) way.
- *
- * @param pSrc Source array of height = nSrcHeight and width = nSrcWidth.
- * @param pDst Destination transposed array of height = nSrcWidth and width = nSrcHeight.
- * @param nSrcWidth Width of pSrc array.
- * @param nSrcHeight Height of pSrc array.
- */
-
-template <class DST, class SRC>
-void GDALTranspose2DSingleToSingle(const SRC *CPL_RESTRICT pSrc,
-                                   DST *CPL_RESTRICT pDst, size_t nSrcWidth,
-                                   size_t nSrcHeight)
-{
-    constexpr size_t blocksize = 32;
-    for (size_t i = 0; i < nSrcHeight; i += blocksize)
-    {
-        const size_t max_k = std::min(i + blocksize, nSrcHeight);
-        for (size_t j = 0; j < nSrcWidth; j += blocksize)
-        {
-            // transpose the block beginning at [i,j]
-            const size_t max_l = std::min(j + blocksize, nSrcWidth);
-            for (size_t k = i; k < max_k; ++k)
-            {
-                for (size_t l = j; l < max_l; ++l)
-                {
-                    GDALCopyWord(pSrc[l + k * nSrcWidth],
-                                 pDst[k + l * nSrcHeight]);
-                }
-            }
-        }
-    }
-}
-
-/************************************************************************/
-/*                   GDALTranspose2DComplexToComplex()                  */
-/************************************************************************/
-/**
- * Transpose a 2D array of complex values into an array of complex values,
- * in a efficient (cache-oblivious) way.
- *
- * @param pSrc Source array of height = nSrcHeight and width = nSrcWidth.
- * @param pDst Destination transposed array of height = nSrcWidth and width = nSrcHeight.
- * @param nSrcWidth Width of pSrc array.
- * @param nSrcHeight Height of pSrc array.
- */
-template <class DST, class SRC>
-void GDALTranspose2DComplexToComplex(const SRC *CPL_RESTRICT pSrc,
-                                     DST *CPL_RESTRICT pDst, size_t nSrcWidth,
-                                     size_t nSrcHeight)
-{
-    constexpr size_t blocksize = 32;
-    for (size_t i = 0; i < nSrcHeight; i += blocksize)
-    {
-        const size_t max_k = std::min(i + blocksize, nSrcHeight);
-        for (size_t j = 0; j < nSrcWidth; j += blocksize)
-        {
-            // transpose the block beginning at [i,j]
-            const size_t max_l = std::min(j + blocksize, nSrcWidth);
-            for (size_t k = i; k < max_k; ++k)
-            {
-                for (size_t l = j; l < max_l; ++l)
-                {
-                    GDALCopyWord(pSrc[2 * (l + k * nSrcWidth) + 0],
-                                 pDst[2 * (k + l * nSrcHeight) + 0]);
-                    GDALCopyWord(pSrc[2 * (l + k * nSrcWidth) + 1],
-                                 pDst[2 * (k + l * nSrcHeight) + 1]);
-                }
-            }
-        }
-    }
-}
-
-/************************************************************************/
-/*                   GDALTranspose2DComplexToSingle()                  */
-/************************************************************************/
-/**
- * Transpose a 2D array of complex values into an array of non-complex values,
- * in a efficient (cache-oblivious) way.
- *
- * @param pSrc Source array of height = nSrcHeight and width = nSrcWidth.
- * @param pDst Destination transposed array of height = nSrcWidth and width = nSrcHeight.
- * @param nSrcWidth Width of pSrc array.
- * @param nSrcHeight Height of pSrc array.
- */
-template <class DST, class SRC>
-void GDALTranspose2DComplexToSingle(const SRC *CPL_RESTRICT pSrc,
-                                    DST *CPL_RESTRICT pDst, size_t nSrcWidth,
-                                    size_t nSrcHeight)
-{
-    constexpr size_t blocksize = 32;
-    for (size_t i = 0; i < nSrcHeight; i += blocksize)
-    {
-        const size_t max_k = std::min(i + blocksize, nSrcHeight);
-        for (size_t j = 0; j < nSrcWidth; j += blocksize)
-        {
-            // transpose the block beginning at [i,j]
-            const size_t max_l = std::min(j + blocksize, nSrcWidth);
-            for (size_t k = i; k < max_k; ++k)
-            {
-                for (size_t l = j; l < max_l; ++l)
-                {
-                    GDALCopyWord(pSrc[2 * (l + k * nSrcWidth) + 0],
-                                 pDst[k + l * nSrcHeight]);
-                }
-            }
-        }
-    }
-}
-
-/************************************************************************/
-/*                   GDALTranspose2DSingleToComplex()                  */
-/************************************************************************/
-/**
- * Transpose a 2D array of non-complex values into an array of complex values,
- * in a efficient (cache-oblivious) way.
- *
- * @param pSrc Source array of height = nSrcHeight and width = nSrcWidth.
- * @param pDst Destination transposed array of height = nSrcWidth and width = nSrcHeight.
- * @param nSrcWidth Width of pSrc array.
- * @param nSrcHeight Height of pSrc array.
- */
-template <class DST, class SRC>
-void GDALTranspose2DSingleToComplex(const SRC *CPL_RESTRICT pSrc,
-                                    DST *CPL_RESTRICT pDst, size_t nSrcWidth,
-                                    size_t nSrcHeight)
-{
-    constexpr size_t blocksize = 32;
-    for (size_t i = 0; i < nSrcHeight; i += blocksize)
-    {
-        const size_t max_k = std::min(i + blocksize, nSrcHeight);
-        for (size_t j = 0; j < nSrcWidth; j += blocksize)
-        {
-            // transpose the block beginning at [i,j]
-            const size_t max_l = std::min(j + blocksize, nSrcWidth);
-            for (size_t k = i; k < max_k; ++k)
-            {
-                for (size_t l = j; l < max_l; ++l)
-                {
-                    GDALCopyWord(pSrc[l + k * nSrcWidth],
-                                 pDst[2 * (k + l * nSrcHeight) + 0]);
-                    pDst[2 * (k + l * nSrcHeight) + 1] = 0;
-                }
-            }
-        }
-    }
-}
-
 #endif  // GDAL_PRIV_TEMPLATES_HPP_INCLUDED
diff --git a/gcore/rasterio.cpp b/gcore/rasterio.cpp
index 7ba73aa49f50..2f0ef7ba8ebf 100644
--- a/gcore/rasterio.cpp
+++ b/gcore/rasterio.cpp
@@ -5676,6 +5676,157 @@ void GDALDeinterleave(const void *pSourceBuffer, GDALDataType eSourceDT,
     }
 }
 
+/************************************************************************/
+/*                    GDALTranspose2DSingleToSingle()                   */
+/************************************************************************/
+/**
+ * Transpose a 2D array of non-complex values, in a efficient (cache-oblivious) way.
+ *
+ * @param pSrc Source array of height = nSrcHeight and width = nSrcWidth.
+ * @param pDst Destination transposed array of height = nSrcWidth and width = nSrcHeight.
+ * @param nSrcWidth Width of pSrc array.
+ * @param nSrcHeight Height of pSrc array.
+ */
+
+template <class DST, class SRC>
+void GDALTranspose2DSingleToSingle(const SRC *CPL_RESTRICT pSrc,
+                                   DST *CPL_RESTRICT pDst, size_t nSrcWidth,
+                                   size_t nSrcHeight)
+{
+    constexpr size_t blocksize = 32;
+    for (size_t i = 0; i < nSrcHeight; i += blocksize)
+    {
+        const size_t max_k = std::min(i + blocksize, nSrcHeight);
+        for (size_t j = 0; j < nSrcWidth; j += blocksize)
+        {
+            // transpose the block beginning at [i,j]
+            const size_t max_l = std::min(j + blocksize, nSrcWidth);
+            for (size_t k = i; k < max_k; ++k)
+            {
+                for (size_t l = j; l < max_l; ++l)
+                {
+                    GDALCopyWord(pSrc[l + k * nSrcWidth],
+                                 pDst[k + l * nSrcHeight]);
+                }
+            }
+        }
+    }
+}
+
+/************************************************************************/
+/*                   GDALTranspose2DComplexToComplex()                  */
+/************************************************************************/
+/**
+ * Transpose a 2D array of complex values into an array of complex values,
+ * in a efficient (cache-oblivious) way.
+ *
+ * @param pSrc Source array of height = nSrcHeight and width = nSrcWidth.
+ * @param pDst Destination transposed array of height = nSrcWidth and width = nSrcHeight.
+ * @param nSrcWidth Width of pSrc array.
+ * @param nSrcHeight Height of pSrc array.
+ */
+template <class DST, class SRC>
+void GDALTranspose2DComplexToComplex(const SRC *CPL_RESTRICT pSrc,
+                                     DST *CPL_RESTRICT pDst, size_t nSrcWidth,
+                                     size_t nSrcHeight)
+{
+    constexpr size_t blocksize = 32;
+    for (size_t i = 0; i < nSrcHeight; i += blocksize)
+    {
+        const size_t max_k = std::min(i + blocksize, nSrcHeight);
+        for (size_t j = 0; j < nSrcWidth; j += blocksize)
+        {
+            // transpose the block beginning at [i,j]
+            const size_t max_l = std::min(j + blocksize, nSrcWidth);
+            for (size_t k = i; k < max_k; ++k)
+            {
+                for (size_t l = j; l < max_l; ++l)
+                {
+                    GDALCopyWord(pSrc[2 * (l + k * nSrcWidth) + 0],
+                                 pDst[2 * (k + l * nSrcHeight) + 0]);
+                    GDALCopyWord(pSrc[2 * (l + k * nSrcWidth) + 1],
+                                 pDst[2 * (k + l * nSrcHeight) + 1]);
+                }
+            }
+        }
+    }
+}
+
+/************************************************************************/
+/*                   GDALTranspose2DComplexToSingle()                  */
+/************************************************************************/
+/**
+ * Transpose a 2D array of complex values into an array of non-complex values,
+ * in a efficient (cache-oblivious) way.
+ *
+ * @param pSrc Source array of height = nSrcHeight and width = nSrcWidth.
+ * @param pDst Destination transposed array of height = nSrcWidth and width = nSrcHeight.
+ * @param nSrcWidth Width of pSrc array.
+ * @param nSrcHeight Height of pSrc array.
+ */
+template <class DST, class SRC>
+void GDALTranspose2DComplexToSingle(const SRC *CPL_RESTRICT pSrc,
+                                    DST *CPL_RESTRICT pDst, size_t nSrcWidth,
+                                    size_t nSrcHeight)
+{
+    constexpr size_t blocksize = 32;
+    for (size_t i = 0; i < nSrcHeight; i += blocksize)
+    {
+        const size_t max_k = std::min(i + blocksize, nSrcHeight);
+        for (size_t j = 0; j < nSrcWidth; j += blocksize)
+        {
+            // transpose the block beginning at [i,j]
+            const size_t max_l = std::min(j + blocksize, nSrcWidth);
+            for (size_t k = i; k < max_k; ++k)
+            {
+                for (size_t l = j; l < max_l; ++l)
+                {
+                    GDALCopyWord(pSrc[2 * (l + k * nSrcWidth) + 0],
+                                 pDst[k + l * nSrcHeight]);
+                }
+            }
+        }
+    }
+}
+
+/************************************************************************/
+/*                   GDALTranspose2DSingleToComplex()                  */
+/************************************************************************/
+/**
+ * Transpose a 2D array of non-complex values into an array of complex values,
+ * in a efficient (cache-oblivious) way.
+ *
+ * @param pSrc Source array of height = nSrcHeight and width = nSrcWidth.
+ * @param pDst Destination transposed array of height = nSrcWidth and width = nSrcHeight.
+ * @param nSrcWidth Width of pSrc array.
+ * @param nSrcHeight Height of pSrc array.
+ */
+template <class DST, class SRC>
+void GDALTranspose2DSingleToComplex(const SRC *CPL_RESTRICT pSrc,
+                                    DST *CPL_RESTRICT pDst, size_t nSrcWidth,
+                                    size_t nSrcHeight)
+{
+    constexpr size_t blocksize = 32;
+    for (size_t i = 0; i < nSrcHeight; i += blocksize)
+    {
+        const size_t max_k = std::min(i + blocksize, nSrcHeight);
+        for (size_t j = 0; j < nSrcWidth; j += blocksize)
+        {
+            // transpose the block beginning at [i,j]
+            const size_t max_l = std::min(j + blocksize, nSrcWidth);
+            for (size_t k = i; k < max_k; ++k)
+            {
+                for (size_t l = j; l < max_l; ++l)
+                {
+                    GDALCopyWord(pSrc[l + k * nSrcWidth],
+                                 pDst[2 * (k + l * nSrcHeight) + 0]);
+                    pDst[2 * (k + l * nSrcHeight) + 1] = 0;
+                }
+            }
+        }
+    }
+}
+
 /************************************************************************/
 /*                        GDALTranspose2D()                             */
 /************************************************************************/

From c2c413f7be7df09afb945ba22ad8492acacae858 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Tue, 7 Jan 2025 04:06:20 +0100
Subject: [PATCH 38/40] Fix completion of 'gdal raster pipeline read <TAB>'

---
 apps/gdalalg_abstract_pipeline.h | 3 ++-
 autotest/utilities/test_gdal.py  | 5 +++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/apps/gdalalg_abstract_pipeline.h b/apps/gdalalg_abstract_pipeline.h
index 36a0d0616681..5ac5a2ea5c85 100644
--- a/apps/gdalalg_abstract_pipeline.h
+++ b/apps/gdalalg_abstract_pipeline.h
@@ -83,7 +83,8 @@ GDALAbstractPipelineAlgorithm<StepAlgorithm>::GetAutoComplete(
     std::vector<std::string> ret;
     if (args.size() <= 1)
     {
-        ret.push_back("read");
+        if (args.empty() || args.front() != "read")
+            ret.push_back("read");
     }
     else if (args.back() == "!" || args[args.size() - 2] == "!")
     {
diff --git a/autotest/utilities/test_gdal.py b/autotest/utilities/test_gdal.py
index 6c7cf0546bae..ef1f50efaf18 100755
--- a/autotest/utilities/test_gdal.py
+++ b/autotest/utilities/test_gdal.py
@@ -353,6 +353,11 @@ def test_gdal_completion_pipeline(gdal_path, subcommand):
     ).split(" ")
     assert out == ["read"]
 
+    out = gdaltest.runexternal(
+        f"{gdal_path} completion gdal {subcommand} pipeline read"
+    ).split(" ")
+    assert out == [""]
+
     out = gdaltest.runexternal(
         f"{gdal_path} completion gdal {subcommand} pipeline read -"
     ).split(" ")

From beaa9c530dc735e2341553017fd639d2ac826e62 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Tue, 7 Jan 2025 04:06:40 +0100
Subject: [PATCH 39/40] Docker: make sure Bash completion is enabled

---
 docker/alpine-normal/Dockerfile | 3 +++
 docker/alpine-small/Dockerfile  | 3 +++
 docker/ubuntu-full/Dockerfile   | 6 +++++-
 docker/ubuntu-small/Dockerfile  | 6 +++++-
 4 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/docker/alpine-normal/Dockerfile b/docker/alpine-normal/Dockerfile
index 5be0a49898a1..fa53d5d639c7 100644
--- a/docker/alpine-normal/Dockerfile
+++ b/docker/alpine-normal/Dockerfile
@@ -323,6 +323,7 @@ RUN date
 
 RUN apk add --no-cache \
         armadillo \
+        bash-completion \
         basisu \
         blosc \
         brotli-libs \
@@ -418,3 +419,5 @@ COPY --from=builder  /build/usr/share/gdal/ /usr/share/gdal/
 COPY --from=builder  /build/usr/include/ /usr/include/
 COPY --from=builder  /build_gdal_python/usr/ /usr/
 COPY --from=builder  /build_gdal_version_changing/usr/ /usr/
+
+CMD ["/bin/bash", "-l"]
diff --git a/docker/alpine-small/Dockerfile b/docker/alpine-small/Dockerfile
index bafacae7831f..88ffca12b34d 100644
--- a/docker/alpine-small/Dockerfile
+++ b/docker/alpine-small/Dockerfile
@@ -172,6 +172,7 @@ RUN date
 
 RUN apk add --no-cache \
         libstdc++ \
+        bash-completion \
         sqlite-libs \
         libcurl tiff \
         zlib zstd-libs lz4-libs libdeflate libarchive \
@@ -195,3 +196,5 @@ COPY --from=builder  /build/usr/share/bash-completion/ /usr/share/bash-completio
 COPY --from=builder  /build/usr/share/gdal/ /usr/share/gdal/
 COPY --from=builder  /build/usr/include/ /usr/include/
 COPY --from=builder  /build_gdal_version_changing/usr/ /usr/
+
+CMD ["/bin/bash", "-l"]
diff --git a/docker/ubuntu-full/Dockerfile b/docker/ubuntu-full/Dockerfile
index 5b65e42ef6b3..d6b6821c37b9 100644
--- a/docker/ubuntu-full/Dockerfile
+++ b/docker/ubuntu-full/Dockerfile
@@ -527,7 +527,7 @@ RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
         wget curl unzip ca-certificates \
     # GDAL dependencies
     && apt-get install -y \
-        libopenjp2-7 libcairo2 python3-numpy \
+        bash-completion libopenjp2-7 libcairo2 python3-numpy \
         libpng16-16 libjpeg-turbo8 libgif7 liblzma5 libgeos3.12.1 libgeos-c1v5 \
         libxml2 libexpat1 \
         libxerces-c3.2 libnetcdf-c++4-1 netcdf-bin libpoppler134 libspatialite8 librasterlite2-1 gpsbabel \
@@ -619,3 +619,7 @@ RUN ldconfig
 RUN if test "$(uname -p)" = "x86_64"; then \
     ogrinfo ADBC::memory: -oo ADBC_DRIVER=duckdb -oo PRELUDE_STATEMENTS="INSTALL spatial"; \
     fi
+
+RUN echo "source /usr/share/bash-completion/bash_completion" >> /root/.bashrc
+
+CMD ["/bin/bash", "-l"]
diff --git a/docker/ubuntu-small/Dockerfile b/docker/ubuntu-small/Dockerfile
index fe511e32c7cd..8ec7c062af66 100644
--- a/docker/ubuntu-small/Dockerfile
+++ b/docker/ubuntu-small/Dockerfile
@@ -235,7 +235,7 @@ RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
         curl unzip ca-certificates \
     # GDAL dependencies
     && apt-get install -y --no-install-recommends \
-        python3-numpy libpython3.12 \
+        bash-completion python3-numpy libpython3.12 \
         libjpeg-turbo8 libgeos3.12.1 libgeos-c1v5 \
         libexpat1 \
         libxerces-c3.2 \
@@ -265,3 +265,7 @@ COPY --from=builder  /build_gdal_python/usr/ /usr/
 COPY --from=builder  /build_gdal_version_changing/usr/ /usr/
 
 RUN ldconfig
+
+RUN echo "source /usr/share/bash-completion/bash_completion" >> /root/.bashrc
+
+CMD ["/bin/bash", "-l"]

From 17d995e061a9355e0da52ebd2babb535ec414bf7 Mon Sep 17 00:00:00 2001
From: Even Rouault <even.rouault@spatialys.com>
Date: Tue, 7 Jan 2025 04:50:18 +0100
Subject: [PATCH 40/40] Make cppcheck master happy

---
 port/cpl_path.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/port/cpl_path.cpp b/port/cpl_path.cpp
index 8be5c27d71dc..5b856dfd71ca 100644
--- a/port/cpl_path.cpp
+++ b/port/cpl_path.cpp
@@ -685,6 +685,7 @@ const char *CPLFormFilename(const char *pszPath, const char *pszBasename,
             }
             else
             {
+                // cppcheck redundantAssignment
                 pszBasename = pszBasenameOri;
                 nLenPath = nLenPathOri;
                 if (pszAddedPathSep[0] == 0)