rt_raster_gdal_drivers()

rt_gdaldriver rt_raster_gdal_drivers	(	uint32_t *	drv_count,
		uint8_t	can_write
	)

Returns a set of available GDAL drivers.

Parameters

drv_count	: number of GDAL drivers available
can_write	: if non-zero, filter drivers to only those with support for CreateCopy and VirtualIO

Returns

set of "gdaldriver" values of available GDAL drivers

Definition at line 1711 of file rt_raster.c.

                                                               {
        const char *cc;
        const char *vio;
        const char *txt;
        int txt_len;
        GDALDriverH *drv = NULL;
        rt_gdaldriver rtn = NULL;
        int count;
        int i;
        uint32_t j;
 
        assert(drv_count != NULL);
 
        rt_util_gdal_register_all(0);
        count = GDALGetDriverCount();
        RASTER_DEBUGF(3, "%d drivers found", count);
 
        rtn = (rt_gdaldriver) rtalloc(count * sizeof(struct rt_gdaldriver_t));
        if (NULL == rtn) {
                rterror("rt_raster_gdal_drivers: Could not allocate memory for gdaldriver structure");
                return 0;
        }
 
        for (i = 0, j = 0; i < count; i++) {
                drv = GDALGetDriver(i);
 
#ifdef GDAL_DCAP_RASTER
                /* Starting with GDAL 2.0, vector drivers can also be returned */
                /* Only keep raster drivers */
                const char *is_raster;
                is_raster = GDALGetMetadataItem(drv, GDAL_DCAP_RASTER, NULL);
                if (is_raster == NULL || !EQUAL(is_raster, "YES"))
                        continue;
#endif
 
                /* CreateCopy support */
                cc = GDALGetMetadataItem(drv, GDAL_DCAP_CREATECOPY, NULL);
 
                /* VirtualIO support */
                vio = GDALGetMetadataItem(drv, GDAL_DCAP_VIRTUALIO, NULL);
 
                if (can_write && (cc == NULL || vio == NULL))
                        continue;
 
                /* we can always read what GDAL can load */
                rtn[j].can_read = 1;
                /* we require CreateCopy and VirtualIO support to write to GDAL */
                rtn[j].can_write = (cc != NULL && vio != NULL);
 
                if (rtn[j].can_write) {
                        RASTER_DEBUGF(3, "driver %s (%d) supports CreateCopy() and VirtualIO()", txt, i);
                }
 
                /* index of driver */
                rtn[j].idx = i;
 
                /* short name */
                txt = GDALGetDriverShortName(drv);
                txt_len = strlen(txt);
 
                txt_len = (txt_len + 1) * sizeof(char);
                rtn[j].short_name = (char *) rtalloc(txt_len);
                memcpy(rtn[j].short_name, txt, txt_len);
 
                /* long name */
                txt = GDALGetDriverLongName(drv);
                txt_len = strlen(txt);
 
                txt_len = (txt_len + 1) * sizeof(char);
                rtn[j].long_name = (char *) rtalloc(txt_len);
                memcpy(rtn[j].long_name, txt, txt_len);
 
                /* creation options */
                txt = GDALGetDriverCreationOptionList(drv);
                txt_len = strlen(txt);
 
                txt_len = (txt_len + 1) * sizeof(char);
                rtn[j].create_options = (char *) rtalloc(txt_len);
                memcpy(rtn[j].create_options, txt, txt_len);
 
                j++;
        }
 
        /* free unused memory */
        rtn = rtrealloc(rtn, j * sizeof(struct rt_gdaldriver_t));
        *drv_count = j;
 
        return rtn;
}

References rt_gdaldriver_t::can_read, rt_gdaldriver_t::can_write, genraster::count, rt_gdaldriver_t::create_options, rt_gdaldriver_t::idx, rt_gdaldriver_t::long_name, RASTER_DEBUGF, rt_util_gdal_register_all(), rtalloc(), rterror(), rtrealloc(), and rt_gdaldriver_t::short_name.

Referenced by RASTER_getGDALDrivers(), rtpg_assignHookGDALEnabledDrivers(), and test_gdal_drivers().

Here is the call graph for this function:

Here is the caller graph for this function: