tiledbitmaplayer.hh

Go to the documentation of this file.

/*
 * Scroom - Generic viewer for 2D data
 * Copyright (C) 2009-2022 Kees-Jan Dijkzeul
 *
 * SPDX-License-Identifier: LGPL-2.1
 */
 
#pragma once
 
#include <map>
#include <vector>
 
#include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/thread.hpp>
#include <boost/weak_ptr.hpp>
 
#include <scroom/interface.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     = boost::shared_ptr<TileInitialisationObserver>;
  using WeakPtr = boost::weak_ptr<TileInitialisationObserver>;
 
  virtual void tileCreated(const boost::shared_ptr<CompressedTile>& tile);
 
  virtual void tileFinished(const boost::shared_ptr<CompressedTile>& tile);
};
 
 
class TileLoadingObserver : private Interface
{
public:
  using Ptr     = boost::shared_ptr<TileLoadingObserver>;
  using WeakPtr = boost::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 = boost::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; 
  std::map<ViewInterface::WeakPtr, boost::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();
 
  boost::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 = boost::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;
 
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;
};