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 522 of file rt_serialize.c.

                                      {
        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):%lu",
                sizeof (struct rt_raster_serialized_t));
        RASTER_DEBUGF(3, "sizeof(struct rt_raster_t):%lu",
                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 = (uint8_t)v;
                                ptr += 1;
                                break;
                        }
                        case PT_16BSI: {
                                int16_t v = band->nodataval;
                                memcpy(ptr, &v, 2);
                                ptr += 2;
                                break;
                        }
                        case PT_16BUI: {
                                uint16_t v = band->nodataval;
                                memcpy(ptr, &v, 2);
                                ptr += 2;
                                break;
                        }
                        case PT_32BSI: {
                                int32_t v = band->nodataval;
                                memcpy(ptr, &v, 4);
                                ptr += 4;
                                break;
                        }
                        case PT_32BUI: {
                                uint32_t v = band->nodataval;
                                memcpy(ptr, &v, 4);
                                ptr += 4;
                                break;
                        }
                        case PT_16BF: {
                                uint16_t v = rt_util_float_to_float16((float)band->nodataval);
                                memcpy(ptr, &v, 2);
                                ptr += 2;
                                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 ((ptr-ret) % 8) {
                        *ptr = 0;
                        ++ptr;
                }
 
                /* 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;
}

References BANDTYPE_FLAG_HASNODATA, BANDTYPE_FLAG_ISNODATA, BANDTYPE_FLAG_OFFDB, 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, rt_pixtype_size(), rt_raster_serialized_size(), rt_util_float_to_float16(), rtalloc(), rtdealloc(), rterror(), and rt_raster_serialized_t::size.

Referenced by RASTER_addBand(), RASTER_addBandOutDB(), RASTER_addBandRasterArray(), RASTER_asRaster(), RASTER_band(), RASTER_clip(), RASTER_colorMap(), RASTER_copyBand(), RASTER_fromGDALRaster(), RASTER_fromHexWKB(), RASTER_fromWKB(), RASTER_GDALWarp(), RASTER_in(), RASTER_InterpolateRaster(), RASTER_intersectionFractions(), RASTER_makeEmpty(), RASTER_mapAlgebra2(), RASTER_mapAlgebraExpr(), RASTER_mapAlgebraFct(), RASTER_mapAlgebraFctNgb(), RASTER_nMapAlgebra(), RASTER_nMapAlgebraExpr(), RASTER_noop(), RASTER_reclass(), RASTER_reclass_exact(), 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_tile(), RASTER_union_finalfn(), and test_raster_wkb().

Here is the call graph for this function:

Here is the caller graph for this function: