RASTER_asGDALRaster()

Datum RASTER_asGDALRaster

(

PG_FUNCTION_ARGS

)

Definition at line 148 of file rtpg_gdal.c.

References clamp_srid(), FALSE, POSTGIS_RT_DEBUG, POSTGIS_RT_DEBUGF, rtrowdump::raster, rt_raster_deserialize(), rt_raster_destroy(), rt_raster_get_srid(), rt_raster_to_gdal(), rtpg_getSR(), rtpg_trim(), and SRID_UNKNOWN.

Referenced by RASTER_fromGDALRaster().

{
        rt_pgraster *pgraster = NULL;
        rt_raster raster;

        text *formattext = NULL;
        char *format = NULL;
        char **options = NULL;
        text *optiontext = NULL;
        char *option = NULL;
        int srid = SRID_UNKNOWN;
        char *srs = NULL;

        ArrayType *array;
        Oid etype;
        Datum *e;
        bool *nulls;
        int16 typlen;
        bool typbyval;
        char typalign;
        int n = 0;
        int i = 0;
        int j = 0;

        uint8_t *gdal = NULL;
        uint64_t gdal_size = 0;
        bytea *result = NULL;
        uint64_t result_size = 0;

        POSTGIS_RT_DEBUG(3, "RASTER_asGDALRaster: Starting");

        /* pgraster is null, return null */
        if (PG_ARGISNULL(0)) PG_RETURN_NULL();
        pgraster = (rt_pgraster *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));

        raster = rt_raster_deserialize(pgraster, FALSE);
        if (!raster) {
                PG_FREE_IF_COPY(pgraster, 0);
                elog(ERROR, "RASTER_asGDALRaster: Could not deserialize raster");
                PG_RETURN_NULL();
        }

        /* format is required */
        if (PG_ARGISNULL(1)) {
                elog(NOTICE, "Format must be provided");
                rt_raster_destroy(raster);
                PG_FREE_IF_COPY(pgraster, 0);
                PG_RETURN_NULL();
        }
        else {
                formattext = PG_GETARG_TEXT_P(1);
                format = text_to_cstring(formattext);
        }

        POSTGIS_RT_DEBUGF(3, "RASTER_asGDALRaster: Arg 1 (format) is %s", format);

        /* process options */
        if (!PG_ARGISNULL(2)) {
                POSTGIS_RT_DEBUG(3, "RASTER_asGDALRaster: Processing Arg 2 (options)");
                array = PG_GETARG_ARRAYTYPE_P(2);
                etype = ARR_ELEMTYPE(array);
                get_typlenbyvalalign(etype, &typlen, &typbyval, &typalign);

                switch (etype) {
                        case TEXTOID:
                                break;
                        default:
                                rt_raster_destroy(raster);
                                PG_FREE_IF_COPY(pgraster, 0);
                                elog(ERROR, "RASTER_asGDALRaster: Invalid data type for options");
                                PG_RETURN_NULL();
                                break;
                }

                deconstruct_array(array, etype, typlen, typbyval, typalign, &e,
                        &nulls, &n);

                if (n) {
                        options = (char **) palloc(sizeof(char *) * (n + 1));
                        if (options == NULL) {
                                rt_raster_destroy(raster);
                                PG_FREE_IF_COPY(pgraster, 0);
                                elog(ERROR, "RASTER_asGDALRaster: Could not allocate memory for options");
                                PG_RETURN_NULL();
                        }

                        /* clean each option */
                        for (i = 0, j = 0; i < n; i++) {
                                if (nulls[i]) continue;

                                option = NULL;
                                switch (etype) {
                                        case TEXTOID:
                                                optiontext = (text *) DatumGetPointer(e[i]);
                                                if (NULL == optiontext) break;
                                                option = text_to_cstring(optiontext);

                                                /* trim string */
                                                option = rtpg_trim(option);
                                                POSTGIS_RT_DEBUGF(3, "RASTER_asGDALRaster: option is '%s'", option);
                                                break;
                                }

                                if (strlen(option)) {
                                        options[j] = (char *) palloc(sizeof(char) * (strlen(option) + 1));
                                        options[j] = option;
                                        j++;
                                }
                        }

                        if (j > 0) {
                                /* trim allocation */
                                options = repalloc(options, (j + 1) * sizeof(char *));

                                /* add NULL to end */
                                options[j] = NULL;

                        }
                        else {
                                pfree(options);
                                options = NULL;
                        }
                }
        }

        /* process srid */
        /* NULL srid means use raster's srid */
        if (PG_ARGISNULL(3))
                srid = rt_raster_get_srid(raster);
        else
                srid = PG_GETARG_INT32(3);

        /* get srs from srid */
        if (clamp_srid(srid) != SRID_UNKNOWN) {
                srs = rtpg_getSR(srid);
                if (NULL == srs) {
                        if (NULL != options) {
                                for (i = j - 1; i >= 0; i--) pfree(options[i]);
                                pfree(options);
                        }
                        rt_raster_destroy(raster);
                        PG_FREE_IF_COPY(pgraster, 0);
                        elog(ERROR, "RASTER_asGDALRaster: Could not find srtext for SRID (%d)", srid);
                        PG_RETURN_NULL();
                }
                POSTGIS_RT_DEBUGF(3, "RASTER_asGDALRaster: Arg 3 (srs) is %s", srs);
        }
        else
                srs = NULL;

        POSTGIS_RT_DEBUG(3, "RASTER_asGDALRaster: Generating GDAL raster");
        gdal = rt_raster_to_gdal(raster, srs, format, options, &gdal_size);

        /* free memory */
        if (NULL != options) {
                for (i = j - 1; i >= 0; i--) pfree(options[i]);
                pfree(options);
        }
        if (NULL != srs) pfree(srs);
        rt_raster_destroy(raster);
        PG_FREE_IF_COPY(pgraster, 0);

        if (!gdal) {
                elog(ERROR, "RASTER_asGDALRaster: Could not allocate and generate GDAL raster");
                PG_RETURN_NULL();
        }
        POSTGIS_RT_DEBUGF(3, "RASTER_asGDALRaster: GDAL raster generated with %d bytes", (int) gdal_size);

        /* result is a varlena */
        result_size = gdal_size + VARHDRSZ;
        result = (bytea *) palloc(result_size);
        if (NULL == result) {
                elog(ERROR, "RASTER_asGDALRaster: Insufficient virtual memory for GDAL raster");
                PG_RETURN_NULL();
        }
        SET_VARSIZE(result, result_size);
        memcpy(VARDATA(result), gdal, VARSIZE(result) - VARHDRSZ);

        /* for test output
        FILE *fh = NULL;
        fh = fopen("/tmp/out.dat", "w");
        fwrite(gdal, sizeof(uint8_t), gdal_size, fh);
        fclose(fh);
        */

        /* free gdal mem buffer */
        if (gdal) CPLFree(gdal);

        POSTGIS_RT_DEBUG(3, "RASTER_asGDALRaster: Returning pointer to GDAL raster");
        PG_RETURN_POINTER(result);
}

Here is the call graph for this function:

Here is the caller graph for this function: