rt_raster_deserialize()

rt_raster rt_raster_deserialize	(	void *	serialized,
		int	header_only
	)

Return a raster from a serialized form.

Serialized form is documented in doc/RFC1-SerializedFormat.

NOTE: the raster will contain pointer to the serialized form (including band data), which must be kept alive.

Definition at line 732 of file rt_serialize.c.

                                                         {
        rt_raster rast = NULL;
        const uint8_t *ptr = NULL;
        const uint8_t *beg = NULL;
        uint16_t i = 0;
        uint16_t j = 0;
#ifdef WORDS_BIGENDIAN
        uint8_t littleEndian = LW_FALSE;
#else
        uint8_t littleEndian = LW_TRUE;
#endif
 
        assert(NULL != serialized);
 
        RASTER_DEBUG(2, "rt_raster_deserialize: Entering...");
 
        /* NOTE: Value of rt_raster.size may be different
         * than actual size of raster data being read.
         * See note on SET_VARSIZE in rt_raster_serialize function above.
         */
 
        /* Allocate memory for deserialized raster header */
        RASTER_DEBUG(3, "rt_raster_deserialize: Allocating memory for deserialized raster header");
        rast = (rt_raster) rtalloc(sizeof (struct rt_raster_t));
        if (!rast) {
                rterror("rt_raster_deserialize: Out of memory allocating raster for deserialization");
                return NULL;
        }
 
        /* Deserialize raster header */
        RASTER_DEBUG(3, "rt_raster_deserialize: Deserialize raster header");
        memcpy(rast, serialized, sizeof (struct rt_raster_serialized_t));
 
        if (0 == rast->numBands || header_only) {
                rast->bands = 0;
                return rast;
        }
 
        beg = (const uint8_t*) serialized;
 
        /* Allocate registry of raster bands */
        RASTER_DEBUG(3, "rt_raster_deserialize: Allocating memory for bands");
        rast->bands = rtalloc(rast->numBands * sizeof (rt_band));
        if (rast->bands == NULL) {
                rterror("rt_raster_deserialize: Out of memory allocating bands");
                rtdealloc(rast);
                return NULL;
        }
 
        RASTER_DEBUGF(3, "rt_raster_deserialize: %d bands", rast->numBands);
 
        /* Move to the beginning of first band */
        ptr = beg;
        ptr += sizeof (struct rt_raster_serialized_t);
 
        /* Deserialize bands now */
        for (i = 0; i < rast->numBands; ++i) {
                rt_band band = NULL;
                uint8_t type = 0;
                int pixbytes = 0;
 
                band = rtalloc(sizeof(struct rt_band_t));
                if (!band) {
                        rterror("rt_raster_deserialize: Out of memory allocating rt_band during deserialization");
                        for (j = 0; j < i; j++) rt_band_destroy(rast->bands[j]);
                        rt_raster_destroy(rast);
                        return NULL;
                }
 
                rast->bands[i] = band;
 
                type = *ptr;
                ptr++;
                band->pixtype = type & BANDTYPE_PIXTYPE_MASK;
 
                RASTER_DEBUGF(3, "rt_raster_deserialize: band %d with pixel type %s", i, rt_pixtype_name(band->pixtype));
 
                band->offline = BANDTYPE_IS_OFFDB(type) ? 1 : 0;
                band->hasnodata = BANDTYPE_HAS_NODATA(type) ? 1 : 0;
                band->isnodata = band->hasnodata ? (BANDTYPE_IS_NODATA(type) ? 1 : 0) : 0;
                band->width = rast->width;
                band->height = rast->height;
                band->ownsdata = 0; /* we do NOT own this data!!! */
                band->raster = rast;
 
                /* Advance by data padding */
                pixbytes = rt_pixtype_size(band->pixtype);
                ptr += pixbytes - 1;
 
                /* Read nodata value */
                switch (band->pixtype) {
                        case PT_1BB: {
                                band->nodataval = ((int) read_uint8(&ptr)) & 0x01;
                                break;
                        }
                        case PT_2BUI: {
                                band->nodataval = ((int) read_uint8(&ptr)) & 0x03;
                                break;
                        }
                        case PT_4BUI: {
                                band->nodataval = ((int) read_uint8(&ptr)) & 0x0F;
                                break;
                        }
                        case PT_8BSI: {
                                band->nodataval = read_int8(&ptr);
                                break;
                        }
                        case PT_8BUI: {
                                band->nodataval = read_uint8(&ptr);
                                break;
                        }
                        case PT_16BSI: {
                                band->nodataval = read_int16(&ptr, littleEndian);
                                break;
                        }
                        case PT_16BUI: {
                                band->nodataval = read_uint16(&ptr, littleEndian);
                                break;
                        }
                        case PT_32BSI: {
                                band->nodataval = read_int32(&ptr, littleEndian);
                                break;
                        }
                        case PT_32BUI: {
                                band->nodataval = read_uint32(&ptr, littleEndian);
                                break;
                        }
                        case PT_16BF: {
                                band->nodataval = rt_util_float16_to_float(read_uint16(&ptr, littleEndian));
                                break;
                        }
                        case PT_32BF: {
                                band->nodataval = read_float32(&ptr, littleEndian);
                                break;
                        }
                        case PT_64BF: {
                                band->nodataval = read_float64(&ptr, littleEndian);
                                break;
                        }
                        default: {
                                rterror("rt_raster_deserialize: Unknown pixeltype %d", band->pixtype);
                                for (j = 0; j <= i; j++) rt_band_destroy(rast->bands[j]);
                                rt_raster_destroy(rast);
                                return NULL;
                        }
                }
 
                RASTER_DEBUGF(3, "rt_raster_deserialize: has nodata flag %d", band->hasnodata);
                RASTER_DEBUGF(3, "rt_raster_deserialize: nodata value %g", band->nodataval);
 
                /* Consistency checking (ptr is pixbytes-aligned) */
                assert(!((ptr - beg) % pixbytes));
 
                if (band->offline) {
                        int pathlen = 0;
 
                        /* Read band number */
                        band->data.offline.bandNum = *ptr;
                        ptr += 1;
 
                        /* Register path */
                        pathlen = strlen((char*) ptr);
                        band->data.offline.path = rtalloc(sizeof(char) * (pathlen + 1));
                        if (band->data.offline.path == NULL) {
                                rterror("rt_raster_deserialize: Could not allocate memory for offline band path");
                                for (j = 0; j <= i; j++) rt_band_destroy(rast->bands[j]);
                                rt_raster_destroy(rast);
                                return NULL;
                        }
 
                        memcpy(band->data.offline.path, ptr, pathlen);
                        band->data.offline.path[pathlen] = '\0';
                        ptr += pathlen + 1;
 
                        band->data.offline.mem = NULL;
                }
                else {
                        /* Register data */
                        const uint32_t datasize = rast->width * rast->height * pixbytes;
                        band->data.mem = (uint8_t*) ptr;
                        ptr += datasize;
                }
 
                /* Skip bytes of padding up to 8-bytes boundary */
#if POSTGIS_DEBUG_LEVEL > 0
                const uint8_t *padbeg = ptr;
#endif
                while (0 != ((ptr - beg) % 8)) {
                        ++ptr;
                }
 
                RASTER_DEBUGF(3, "rt_raster_deserialize: skip %ld bytes of 8-bytes boundary padding", ptr - padbeg);
 
                /* Consistency checking (ptr is pixbytes-aligned) */
                assert(!((ptr - beg) % pixbytes));
        }
 
        return rast;
}

References BANDTYPE_HAS_NODATA, BANDTYPE_IS_NODATA, BANDTYPE_IS_OFFDB, BANDTYPE_PIXTYPE_MASK, LW_FALSE, LW_TRUE, PT_16BF, PT_16BSI, PT_16BUI, PT_1BB, PT_2BUI, PT_32BF, PT_32BSI, PT_32BUI, PT_4BUI, PT_64BF, PT_8BSI, PT_8BUI, RASTER_DEBUG, RASTER_DEBUGF, read_float32(), read_float64(), read_int16(), read_int32(), read_int8(), read_uint16(), read_uint32(), read_uint8(), rt_band_destroy(), rt_pixtype_name(), rt_pixtype_size(), rt_raster_destroy(), rt_util_float16_to_float(), rtalloc(), rtdealloc(), and rterror().

Referenced by RASTER_addBand(), RASTER_addBandOutDB(), RASTER_addBandRasterArray(), RASTER_asGDALRaster(), RASTER_asHexWKB(), RASTER_asWKB(), RASTER_band(), RASTER_bandIsNoData(), RASTER_bandmetadata(), RASTER_clip(), RASTER_colorMap(), RASTER_contains(), RASTER_containsProperly(), RASTER_Contour(), RASTER_convex_hull(), RASTER_copyBand(), RASTER_coveredby(), RASTER_covers(), RASTER_dfullywithin(), RASTER_dumpAsPolygons(), RASTER_dumpValues(), RASTER_dwithin(), RASTER_envelope(), RASTER_GDALWarp(), RASTER_getBandFileSize(), RASTER_getBandFileTimestamp(), RASTER_getBandNoDataValue(), RASTER_getBandPath(), RASTER_getBandPixelType(), RASTER_getBandPixelTypeName(), RASTER_getGeometryValues(), RASTER_getGeotransform(), RASTER_getHeight(), RASTER_getNumBands(), RASTER_getPixelCentroids(), RASTER_getPixelHeight(), RASTER_getPixelPolygons(), RASTER_getPixelValue(), RASTER_getPixelValueResample(), RASTER_getPixelWidth(), RASTER_getPolygon(), RASTER_getSRID(), RASTER_getWidth(), RASTER_getXScale(), RASTER_getXSkew(), RASTER_getXUpperLeft(), RASTER_getYScale(), RASTER_getYSkew(), RASTER_getYUpperLeft(), RASTER_hasNoBand(), RASTER_histogram(), RASTER_InterpolateRaster(), RASTER_intersectionFractions(), RASTER_intersects(), RASTER_isEmpty(), RASTER_mapAlgebra2(), RASTER_mapAlgebraExpr(), RASTER_mapAlgebraFct(), RASTER_mapAlgebraFctNgb(), RASTER_metadata(), RASTER_nearestValue(), RASTER_neighborhood(), RASTER_nMapAlgebra(), RASTER_noop(), RASTER_notSameAlignmentReason(), RASTER_out(), RASTER_overlaps(), RASTER_pixelOfValue(), RASTER_quantile(), RASTER_rasterToWorldCoord(), RASTER_reclass(), RASTER_reclass_exact(), RASTER_sameAlignment(), RASTER_setBandIsNoData(), RASTER_setBandNoDataValue(), RASTER_setBandPath(), RASTER_setGeotransform(), RASTER_setPixelValue(), RASTER_setPixelValuesArray(), RASTER_setPixelValuesGeomval(), RASTER_setRotation(), RASTER_setScale(), RASTER_setScaleXY(), RASTER_setSkew(), RASTER_setSkewXY(), RASTER_setSRID(), RASTER_setUpperLeftXY(), RASTER_summaryStats(), RASTER_summaryStats_transfn(), RASTER_summaryStatsCoverage(), RASTER_tile(), RASTER_to_bytea(), RASTER_touches(), RASTER_union_transfn(), RASTER_valueCount(), RASTER_valueCountCoverage(), RASTER_worldToRasterCoord(), rtpg_nmapalgebra_rastbandarg_process(), and test_raster_wkb().

Here is the call graph for this function: