rt_band_from_wkb()

static rt_band rt_band_from_wkb ( uint16_t  width, uint16_t  height, const uint8_t **  ptr, const uint8_t *  end, uint8_t  littleEndian  )

static

Definition at line 39 of file rt_wkb.c.

  {
        rt_band band = NULL;
        int pixbytes = 0;
        uint8_t type = 0;
        size_t sz = 0;
        size_t v = 0;
 
        assert(NULL != ptr);
        assert(NULL != end);
 
        band = rtalloc(sizeof (struct rt_band_t));
        if (!band) {
                rterror("rt_band_from_wkb: Out of memory allocating rt_band during WKB parsing");
                return NULL;
        }
        band->ownsdata = 0; /* assume we don't own data */
 
        if (end - *ptr < 1) {
                rterror("rt_band_from_wkb: Premature end of WKB on band reading (%s:%d)",
                        __FILE__, __LINE__);
                rt_band_destroy(band);
                return NULL;
        }
        type = read_uint8(ptr);
 
        if ((type & BANDTYPE_PIXTYPE_MASK) >= PT_END) {
                rterror("rt_band_from_wkb: Invalid pixtype %d", type & BANDTYPE_PIXTYPE_MASK);
                rt_band_destroy(band);
                return NULL;
        }
 
        band->pixtype = type & BANDTYPE_PIXTYPE_MASK;
        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 = width;
        band->height = height;
 
        RASTER_DEBUGF(3, " Band pixtype:%s, offline:%d, hasnodata:%d",
                rt_pixtype_name(band->pixtype),
                band->offline,
                band->hasnodata
        );
 
        /* Check there's enough bytes to read nodata value */
        pixbytes = rt_pixtype_size(band->pixtype);
        if (((*ptr) + pixbytes) >= end) {
                rterror("rt_band_from_wkb: Premature end of WKB on band novalue reading");
                rt_band_destroy(band);
                return NULL;
        }
 
        /* 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_band_from_wkb: Unknown pixeltype %d", band->pixtype);
                        rt_band_destroy(band);
                        return NULL;
                }
        }
 
        RASTER_DEBUGF(3, " Nodata value: %g, pixbytes: %d, ptr @ %p, end @ %p",
                band->nodataval, pixbytes, *ptr, end);
 
        if (band->offline) {
                if (((*ptr) + 1) >= end) {
                        rterror("rt_band_from_wkb: Premature end of WKB on offline "
                                "band data bandNum reading (%s:%d)",
                                __FILE__, __LINE__
                        );
                        rt_band_destroy(band);
                        return NULL;
                }
 
                band->data.offline.bandNum = read_int8(ptr);
                band->data.offline.mem = NULL;
 
                {
                        /* check we have a NULL-termination */
                        sz = 0;
                        while ((*ptr)[sz] && &((*ptr)[sz]) < end) ++sz;
                        if (&((*ptr)[sz]) >= end) {
                                rterror("rt_band_from_wkb: Premature end of WKB on band offline path reading");
                                rt_band_destroy(band);
                                return NULL;
                        }
 
                        /* we never own offline band data */
                        band->ownsdata = 0;
 
                        band->data.offline.path = rtalloc(sz + 1);
                        if (band->data.offline.path == NULL) {
                                rterror("rt_band_from_wkb: Out of memory allocating for offline path of band");
                                rt_band_destroy(band);
                                return NULL;
                        }
 
                        memcpy(band->data.offline.path, *ptr, sz);
                        band->data.offline.path[sz] = '\0';
 
                        RASTER_DEBUGF(3, "OFFDB band path is %s (size is %zu)",
                                band->data.offline.path, sz);
 
                        *ptr += sz + 1;
 
                        /* TODO: How could we know if the offline band is a nodata band? */
                        /* trust in the force */
                        /*band->isnodata = FALSE;*/
                }
 
                return band;
        }
 
        /* This is an on-disk band */
        sz = (size_t)width * height * pixbytes;
        if (((*ptr) + sz) > end) {
                rterror("rt_band_from_wkb: Premature end of WKB on band data reading (%s:%d)",
                        __FILE__, __LINE__);
                rt_band_destroy(band);
                return NULL;
        }
 
        band->data.mem = rtalloc(sz);
        if (!band->data.mem) {
                rterror("rt_band_from_wkb: Out of memory during band creation in WKB parser");
                rt_band_destroy(band);
                return NULL;
        }
 
        band->ownsdata = 1; /* we DO own this data!!! */
        memcpy(band->data.mem, *ptr, sz);
        *ptr += sz;
 
        /* Should now flip values if > 8bit and
         * littleEndian != isMachineLittleEndian */
        if (pixbytes > 1) {
                if (isMachineLittleEndian() != littleEndian) {
                        void (*flipper)(uint8_t*) = 0;
                        uint8_t *flipme = NULL;
 
                        if (pixbytes == 2)
                                flipper = flip_endian_16;
                        else if (pixbytes == 4)
                                flipper = flip_endian_32;
                        else if (pixbytes == 8)
                                flipper = flip_endian_64;
                        else {
                                rterror("rt_band_from_wkb: Unexpected pix bytes %d", pixbytes);
                                rt_band_destroy(band);
                                return NULL;
                        }
 
                        flipme = band->data.mem;
                        sz = (size_t)width * height;
                        for (v = 0; v < sz; ++v) {
                                flipper(flipme);
                                flipme += pixbytes;
                        }
                }
        }
        /* And should check for invalid values for < 8bit types */
        else if (
                band->pixtype == PT_1BB ||
                band->pixtype == PT_2BUI ||
                band->pixtype == PT_4BUI
        ) {
                uint8_t maxVal = band->pixtype == PT_1BB ? 1 : (band->pixtype == PT_2BUI ? 3 : 15);
                uint8_t val;
 
                sz = (size_t)width*height;
                for (v = 0; v < sz; ++v) {
                        val = ((uint8_t*) band->data.mem)[v];
                        if (val > maxVal) {
                                rterror("rt_band_from_wkb: Invalid value %d for pixel of type %s",
                                        val, rt_pixtype_name(band->pixtype));
                                rt_band_destroy(band);
                                return NULL;
                        }
                }
        }
 
        /* And we should check if the band is a nodata band */
        /* TODO: No!! This is too slow */
        /*rt_band_check_is_nodata(band);*/
 
        return band;
}

References BANDTYPE_HAS_NODATA, BANDTYPE_IS_NODATA, BANDTYPE_IS_OFFDB, BANDTYPE_PIXTYPE_MASK, flip_endian_16(), flip_endian_32(), flip_endian_64(), isMachineLittleEndian(), PT_16BF, PT_16BSI, PT_16BUI, PT_1BB, PT_2BUI, PT_32BF, PT_32BSI, PT_32BUI, PT_4BUI, PT_64BF, PT_8BSI, PT_8BUI, PT_END, 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_util_float16_to_float(), rtalloc(), and rterror().

Referenced by rt_raster_from_wkb().

Here is the call graph for this function:

Here is the caller graph for this function: