Method queueNextCompressedChunk

io/LasReader.cpp:516–572

}

void LasReader::queueNextCompressedChunk()
{
    if ((d->nextFetchChunk >= d->chunkInfo.numChunks()) ||
        (d->chunkInfo.firstPoint(d->nextFetchChunk) >= d->end))
        return;

    uint32_t chunk = d->nextFetchChunk;
    uint32_t start = (uint32_t)d->nextFetchPoint;

    d->pool.add([this, chunk, start]()
    {
        uint32_t chunkpoints = d->chunkInfo.chunkPoints(chunk);
        uint64_t chunkoffset = d->chunkInfo.chunkOffset(chunk);
        uint32_t chunksize = d->chunkInfo.chunkSize(chunk);

        LasStreamPtr lasStream = createStream();
        std::istream& in(*lasStream);

        std::vector<char> buf(chunksize);
        in.seekg(chunkoffset);
        in.read(buf.data(), buf.size());

        int32_t tilepoints = chunkpoints - start;
        las::TilePtr tile = std::make_unique<las::Tile>(chunk, tilepoints * d->header.pointSize);

        lazperf::reader::chunk_decompressor decomp(d->header.pointFormat(), d->header.ebCount(),
            buf.data());

        // We have to decompress all the points, even if we're discarding the points at
        // the front because nextFetchPoint isn't 0. Just reuse the front of the tile
        // buffer for discarded points.
        char *pos = tile->data();
        for (uint32_t i = 0; i < chunkpoints; ++i)
        {
            decomp.decompress(pos);

            // Advance the point location in the tile if we're keeping the point.
            if (i >= start)
                pos += d->header.pointSize;
        }
        {
            std::unique_lock l(d->mutex);
            for (las::TilePtr& t : d->tiles)
                if (!t)
                {
                    t = std::move(tile);
                    goto done;
                }
            d->tiles.push_back(std::move(tile));
        }
        done:
        d->processedCv.notify_one();
    });
    d->nextFetchChunk++;
    // After the first chunk, we always start at 0.
    d->nextFetchPoint = 0;
}