rt_raster_serialize()

void* rt_raster_serialize

(

rt_raster

raster

)

Return this raster in serialized form.

Memory (band data included) is copied from rt_raster.

Serialized form is documented in doc/RFC1-SerializedFormat.

Definition at line 521 of file rt_serialize.c.

References ovdump::band, rt_raster_t::bands, BANDTYPE_FLAG_HASNODATA, BANDTYPE_FLAG_ISNODATA, BANDTYPE_FLAG_OFFDB, rt_band_t::data, rt_band_t::hasnodata, rt_raster_t::height, rt_band_t::isnodata, rt_band_t::mem, rt_band_t::nodataval, rt_raster_t::numBands, rt_band_t::offline, rt_band_t::pixtype, 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, rt_pixtype_size(), rt_raster_serialized_size(), rtalloc(), rtdealloc(), rterror(), rt_raster_serialized_t::size, rt_raster_t::size, rt_raster_t::version, and rt_raster_t::width.

Referenced by RASTER_addBand(), RASTER_addBandOutDB(), RASTER_addBandRasterArray(), RASTER_asRaster(), RASTER_band(), RASTER_clip(), RASTER_colorMap(), RASTER_copyBand(), RASTER_fromGDALRaster(), RASTER_GDALWarp(), RASTER_in(), RASTER_makeEmpty(), RASTER_mapAlgebra2(), RASTER_mapAlgebraExpr(), RASTER_mapAlgebraFct(), RASTER_mapAlgebraFctNgb(), RASTER_nMapAlgebra(), RASTER_nMapAlgebraExpr(), RASTER_noop(), RASTER_reclass(), RASTER_setBandIsNoData(), RASTER_setBandNoDataValue(), RASTER_setGeotransform(), RASTER_setPixelValue(), RASTER_setPixelValuesArray(), RASTER_setPixelValuesGeomval(), RASTER_setRotation(), RASTER_setScale(), RASTER_setScaleXY(), RASTER_setSkew(), RASTER_setSkewXY(), RASTER_setSRID(), RASTER_setUpperLeftXY(), RASTER_tile(), RASTER_union_finalfn(), and test_raster_wkb().

                                      {
        uint32_t size = 0;
        uint8_t* ret = NULL;
        uint8_t* ptr = NULL;
        uint16_t i = 0;

        assert(NULL != raster);

        size = rt_raster_serialized_size(raster);
        ret = (uint8_t*) rtalloc(size);
        if (!ret) {
                rterror("rt_raster_serialize: Out of memory allocating %d bytes for serializing a raster", size);
                return NULL;
        }
        memset(ret, '-', size);
        ptr = ret;

        RASTER_DEBUGF(3, "sizeof(struct rt_raster_serialized_t):%u",
                sizeof (struct rt_raster_serialized_t));
        RASTER_DEBUGF(3, "sizeof(struct rt_raster_t):%u",
                sizeof (struct rt_raster_t));
        RASTER_DEBUGF(3, "serialized size:%lu", (long unsigned) size);

        /* Set size */
        /* NOTE: Value of rt_raster.size may be updated in
         * returned object, for instance, by rt_pg layer to
         * store value calculated by SET_VARSIZE.
         */
        raster->size = size;

        /* Set version */
        raster->version = 0;

        /* Copy header */
        memcpy(ptr, raster, sizeof (struct rt_raster_serialized_t));

        RASTER_DEBUG(3, "Start hex dump of raster being serialized using 0x2D to mark non-written bytes");

#if POSTGIS_DEBUG_LEVEL > 2
        uint8_t* dbg_ptr = ptr;
        d_print_binary_hex("HEADER", dbg_ptr, size);
#endif

        ptr += sizeof (struct rt_raster_serialized_t);

        /* Serialize bands now */
        for (i = 0; i < raster->numBands; ++i) {
                rt_band band = raster->bands[i];
                assert(NULL != band);

                rt_pixtype pixtype = band->pixtype;
                int pixbytes = rt_pixtype_size(pixtype);
                if (pixbytes < 1) {
                        rterror("rt_raster_serialize: Corrupted band: unknown pixtype");
                        rtdealloc(ret);
                        return NULL;
                }

                /* Add band type */
                *ptr = band->pixtype;
                if (band->offline) {
#ifdef POSTGIS_RASTER_DISABLE_OFFLINE
      rterror("rt_raster_serialize: offdb raster support disabled at compile-time");
      return NULL;
#endif
                        *ptr |= BANDTYPE_FLAG_OFFDB;
                }
                if (band->hasnodata) {
                        *ptr |= BANDTYPE_FLAG_HASNODATA;
                }

                if (band->isnodata) {
                        *ptr |= BANDTYPE_FLAG_ISNODATA;
                }

#if POSTGIS_DEBUG_LEVEL > 2
                d_print_binary_hex("PIXTYPE", dbg_ptr, size);
#endif

                ptr += 1;

                /* Add padding (if needed) */
                if (pixbytes > 1) {
                        memset(ptr, '\0', pixbytes - 1);
                        ptr += pixbytes - 1;
                }

#if POSTGIS_DEBUG_LEVEL > 2
                d_print_binary_hex("PADDING", dbg_ptr, size);
#endif

                /* Consistency checking (ptr is pixbytes-aligned) */
                assert(!((ptr - ret) % pixbytes));

                /* Add nodata value */
                switch (pixtype) {
                        case PT_1BB:
                        case PT_2BUI:
                        case PT_4BUI:
                        case PT_8BUI: {
                                uint8_t v = band->nodataval;
                                *ptr = v;
                                ptr += 1;
                                break;
                        }
                        case PT_8BSI: {
                                int8_t v = band->nodataval;
                                *ptr = v;
                                ptr += 1;
                                break;
                        }
                        case PT_16BSI:
                        case PT_16BUI: {
                                uint16_t v = band->nodataval;
                                memcpy(ptr, &v, 2);
                                ptr += 2;
                                break;
                        }
                        case PT_32BSI:
                        case PT_32BUI: {
                                uint32_t v = band->nodataval;
                                memcpy(ptr, &v, 4);
                                ptr += 4;
                                break;
                        }
                        case PT_32BF: {
                                float v = band->nodataval;
                                memcpy(ptr, &v, 4);
                                ptr += 4;
                                break;
                        }
                        case PT_64BF: {
                                memcpy(ptr, &band->nodataval, 8);
                                ptr += 8;
                                break;
                        }
                        default:
                                rterror("rt_raster_serialize: Fatal error caused by unknown pixel type. Aborting.");
                                rtdealloc(ret);
                                return NULL;
                }

                /* Consistency checking (ptr is pixbytes-aligned) */
                assert(!((ptr - ret) % pixbytes));

#if POSTGIS_DEBUG_LEVEL > 2
                d_print_binary_hex("nodata", dbg_ptr, size);
#endif

                if (band->offline) {
                        /* Write band number */
                        *ptr = band->data.offline.bandNum;
                        ptr += 1;

                        /* Write path */
                        strcpy((char*) ptr, band->data.offline.path);
                        ptr += strlen(band->data.offline.path) + 1;
                }
                else {
                        /* Write data */
                        uint32_t datasize = raster->width * raster->height * pixbytes;
                        memcpy(ptr, band->data.mem, datasize);
                        ptr += datasize;
                }

#if POSTGIS_DEBUG_LEVEL > 2
                d_print_binary_hex("BAND", dbg_ptr, size);
#endif

                /* Pad up to 8-bytes boundary */
                while ((uintptr_t) ptr % 8) {
                        *ptr = 0;
                        ++ptr;

                        RASTER_DEBUGF(3, "PAD at %d", (uintptr_t) ptr % 8);
                }

                /* Consistency checking (ptr is pixbytes-aligned) */
                assert(!((ptr - ret) % pixbytes));
        } /* for-loop over bands */

#if POSTGIS_DEBUG_LEVEL > 2
                d_print_binary_hex("SERIALIZED RASTER", dbg_ptr, size);
#endif
        return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function: