bool MapReader1500::load(CMap& map, BinaryFile& mapfile, ReadType readtype)
{
read_autofilters(map, mapfile);
if (readtype == read_type_summary)
return true;
map.clearPlatforms();
//Reset position of read cursor
mapfile.rewind();
//clear map (we won't be reading in all the layers so it needs to be cleared)
map.clearMap();
read_tiles(map, mapfile);
read_background(map, mapfile);
read_music_category(map, mapfile);
//All 1.5 maps will use cloud eyecandy
map.eyecandy[2] = 1;
for (short iSwitch = 0; iSwitch < 4; iSwitch++)
map.iSwitches[iSwitch] = 0;
return true;
}
bool
ImageInput::read_tiles (int xbegin, int xend, int ybegin, int yend,
int zbegin, int zend, TypeDesc format, void *data,
stride_t xstride, stride_t ystride, stride_t zstride)
{
return read_tiles (xbegin, xend, ybegin, yend, zbegin, zend,
0, m_spec.nchannels, format, data,
xstride, ystride, zstride);
}
bool
ImageInput::read_image (TypeDesc format, void *data,
stride_t xstride, stride_t ystride, stride_t zstride,
ProgressCallback progress_callback,
void *progress_callback_data)
{
bool native = (format == TypeDesc::UNKNOWN);
stride_t pixel_bytes = native ? (stride_t) m_spec.pixel_bytes (native)
: (stride_t) (format.size()*m_spec.nchannels);
if (native && xstride == AutoStride)
xstride = pixel_bytes;
m_spec.auto_stride (xstride, ystride, zstride, format, m_spec.nchannels,
m_spec.width, m_spec.height);
bool ok = true;
if (progress_callback)
if (progress_callback (progress_callback_data, 0.0f))
return ok;
if (m_spec.tile_width) {
// Tiled image
for (int z = 0; z < m_spec.depth; z += m_spec.tile_depth) {
for (int y = 0; y < m_spec.height; y += m_spec.tile_height) {
ok &= read_tiles (m_spec.x, m_spec.x+m_spec.width,
y+m_spec.y, std::min (y+m_spec.y+m_spec.tile_height, m_spec.y+m_spec.height),
z+m_spec.z, std::min (z+m_spec.z+m_spec.tile_depth, m_spec.z+m_spec.depth),
format, (char *)data + z*zstride + y*ystride,
xstride, ystride, zstride);
if (progress_callback &&
progress_callback (progress_callback_data, (float)y/m_spec.height))
return ok;
}
}
} else {
// Scanline image -- rely on read_scanlines, in chunks of 64
const int chunk = 256;
for (int z = 0; z < m_spec.depth; ++z)
for (int y = 0; y < m_spec.height && ok; y += chunk) {
int yend = std::min (y+m_spec.y+chunk, m_spec.y+m_spec.height);
ok &= read_scanlines (y+m_spec.y, yend, z+m_spec.z, format,
(char *)data + z*zstride + y*ystride,
xstride, ystride);
if (progress_callback)
if (progress_callback (progress_callback_data, (float)y/m_spec.height))
return ok;
}
}
if (progress_callback)
progress_callback (progress_callback_data, 1.0f);
return ok;
}
static bool simple_paint_region(struct _openslide_grid *_grid,
cairo_t *cr,
void *arg,
double x, double y,
struct _openslide_level *level,
int32_t w, int32_t h,
GError **err) {
struct simple_grid *grid = (struct simple_grid *) _grid;
struct region region;
compute_region(_grid, x, y, w, h, ®ion);
// check if completely outside grid
if (region.end_tile_x <= 0 ||
region.end_tile_y <= 0 ||
region.start_tile_x > grid->tiles_across - 1 ||
region.start_tile_y > grid->tiles_down - 1) {
return true;
}
// save
cairo_matrix_t matrix;
cairo_get_matrix(cr, &matrix);
// bound on left/top
int64_t skipped_tiles_x = -MIN(region.start_tile_x, 0);
int64_t skipped_tiles_y = -MIN(region.start_tile_y, 0);
cairo_translate(cr,
skipped_tiles_x * grid->base.tile_advance_x,
skipped_tiles_y * grid->base.tile_advance_y);
region.start_tile_x += skipped_tiles_x;
region.start_tile_y += skipped_tiles_y;
// bound on right/bottom
region.end_tile_x = MIN(region.end_tile_x, grid->tiles_across);
region.end_tile_y = MIN(region.end_tile_y, grid->tiles_down);
// read
bool result = read_tiles(cr, level, _grid, ®ion, arg, err);
// restore
cairo_set_matrix(cr, &matrix);
return result;
}
