tiledbitmaplayer.hh

Go to the documentation of this file.

/*
 * Scroom - Generic viewer for 2D data
 * Copyright (C) 2009-2026 Kees-Jan Dijkzeul
 *
 * SPDX-License-Identifier: LGPL-2.1
 */
 
#pragma once
 
#include <map>
#include <memory>
#include <vector>
 
#include <boost/thread.hpp>
 
#include <scroom/interface.hh>
#include <scroom/logger.hh>
#include <scroom/memoryblobs.hh>
#include <scroom/observable.hh>
#include <scroom/presentationinterface.hh>
#include <scroom/rectangle.hh>
#include <scroom/stuff.hh>
#include <scroom/threadpool.hh>
#include <scroom/tile.hh>
#include <scroom/tiledbitmapinterface.hh>
 
#define TILESIZE 4096
 
enum TileStateInternal
{
  TSI_UNINITIALIZED,
  TSI_NORMAL,
  TSI_OUT_OF_BOUNDS,
  TSI_LOADING_SYNCHRONOUSLY,
  TSI_LOADING_ASYNCHRONOUSLY
};
 
class TileViewState;
class CompressedTile;
 
 
class TileInitialisationObserver : private Interface
{
public:
  using Ptr = std::shared_ptr<TileInitialisationObserver>;
  using WeakPtr = std::weak_ptr<TileInitialisationObserver>;
 
  virtual void tileCreated(const std::shared_ptr<CompressedTile>& tile);
 
  virtual void tileFinished(const std::shared_ptr<CompressedTile>& tile);
};
 
 
class TileLoadingObserver : private Interface
{
public:
  using Ptr = std::shared_ptr<TileLoadingObserver>;
  using WeakPtr = std::weak_ptr<TileLoadingObserver>;
 
  virtual void tileLoaded(ConstTile::Ptr tile) = 0;
};
 
 
class CompressedTile
  : public Scroom::Utils::Observable<TileInitialisationObserver>
  , public Scroom::Utils::Observable<TileLoadingObserver>
  , public Viewable
{
public:
  using Ptr = std::shared_ptr<CompressedTile>;
 
public:
  const int depth; 
  const int x; 
  const int y; 
  const int bpp; 
private:
  TileStateInternal state; 
  Tile::WeakPtr tile; 
  ConstTile::WeakPtr constTile; 
  Scroom::MemoryBlobs::PageProvider::Ptr provider; 
  Scroom::MemoryBlobs::Blob::Ptr data; 
  boost::mutex stateData; 
  boost::mutex tileData; 
  ThreadPool::Queue::WeakPtr queue; 
  Scroom::Utils::WeakKeyMap<ViewInterface::WeakPtr, std::weak_ptr<TileViewState>> viewStates;
 
private:
  CompressedTile(
    int depth,
    int x,
    int y,
    int bpp,
    const Scroom::MemoryBlobs::PageProvider::Ptr& provider,
    TileStateInternal state
  );
 
public:
  static Ptr create(
    int depth,
    int x,
    int y,
    int bpp,
    const Scroom::MemoryBlobs::PageProvider::Ptr& provider,
    TileStateInternal state = TSI_UNINITIALIZED
  );
 
  Tile::Ptr initialize();
 
protected:
  void observerAdded(TileInitialisationObserver::Ptr const& observer, Scroom::Bookkeeping::Token const& token) override;
 
  void observerAdded(TileLoadingObserver::Ptr const& observer, Scroom::Bookkeeping::Token const& token) override;
 
public:
  // To choose between overloaded functions, the compiler needs some extra convincing
  Scroom::Bookkeeping::Token registerStrongObserver(TileInitialisationObserver::Ptr const& observer)
  {
    return Scroom::Utils::Observable<TileInitialisationObserver>::registerStrongObserver(observer);
  }
  Scroom::Bookkeeping::Token registerObserver(TileInitialisationObserver::WeakPtr const& observer)
  {
    return Scroom::Utils::Observable<TileInitialisationObserver>::registerObserver(observer);
  }
  Scroom::Bookkeeping::Token registerStrongObserver(TileLoadingObserver::Ptr const& observer)
  {
    return Scroom::Utils::Observable<TileLoadingObserver>::registerStrongObserver(observer);
  }
  Scroom::Bookkeeping::Token registerObserver(TileLoadingObserver::WeakPtr const& observer)
  {
    return Scroom::Utils::Observable<TileLoadingObserver>::registerObserver(observer);
  }
 
  Tile::Ptr getTileSync();
 
  ConstTile::Ptr getConstTileSync();
 
  ConstTile::Ptr getConstTileAsync();
 
  void reportFinished();
 
  TileState getState();
 
  std::shared_ptr<TileViewState> getViewState(const ViewInterface::WeakPtr& vi);
 
private:
  void cleanupState();
  ConstTile::Ptr do_load();
  void notifyObservers(const ConstTile::Ptr& tile);
 
  // Viewable ////////////////////////////////////////////////////////////
public:
  void open(ViewInterface::WeakPtr vi) override;
  void close(ViewInterface::WeakPtr vi) override;
};
 
using CompressedTileLine = std::vector<CompressedTile::Ptr>;
using CompressedTileGrid = std::vector<CompressedTileLine>;
 
 
class Layer
  : public Viewable
  , public virtual Scroom::Utils::Base
{
public:
  using Ptr = std::shared_ptr<Layer>;
 
private:
  int depth;
  int width;
  int height;
  int horTileCount;
  int verTileCount;
  CompressedTileGrid tiles;
  CompressedTile::Ptr outOfBounds;
  CompressedTileLine lineOutOfBounds;
  Scroom::MemoryBlobs::PageProvider::Ptr pageProvider;
  Scroom::Logger logger;
 
private:
  Layer(int depth, int layerWidth, int layerHeight, int bpp, Scroom::MemoryBlobs::PageProvider::Ptr provider);
 
public:
  static Ptr create(int depth, int layerWidth, int layerHeight, int bpp, Scroom::MemoryBlobs::PageProvider::Ptr provider);
  static Ptr create(int layerWidth, int layerHeight, int bpp);
  int getHorTileCount() const;
  int getVerTileCount() const;
 
  CompressedTile::Ptr getTile(int i, int j);
  CompressedTileLine& getTileLine(int j);
  void fetchData(SourcePresentation::Ptr sp, const ThreadPool::WeakQueue::Ptr& queue, std::function<void()> on_finished);
 
public:
  int getWidth() const { return width; }
 
  int getHeight() const { return height; }
 
  int getDepth() const { return depth; }
 
  Scroom::Utils::Rectangle<int> getRect() const { return {0, 0, width, height}; }
 
  Scroom::Bookkeeping::Token registerObserver(const TileInitialisationObserver::Ptr& observer);
 
  Scroom::MemoryBlobs::PageProvider::Ptr getPageProvider() { return pageProvider; }
 
public:
  // Viewable ////////////////////////////////////////////////////////////
  void open(ViewInterface::WeakPtr vi) override;
  void close(ViewInterface::WeakPtr vi) override;
};