Fix segfault affecting resizing of large streams with small tiles

doc/Changelog.md

@@ -3,6 +3,8 @@ Changelog {#changelog}
 
 # Release 1.5 (git master)
 
+* [275](https://github.com/BlueBrain/Tide/pull/275):
+ Fix a crash that could occur when resizing large pixel streams.
 * [272](https://github.com/BlueBrain/Tide/pull/272):
  - Smooth transitions between resolution levels for opaque contents (PDFs,
  regular TIFF pyramids).

tide/wall/datasources/PixelStreamUpdater.cpp

@@ -91,24 +91,28 @@ const QString& PixelStreamUpdater::getUri() const
 ImagePtr PixelStreamUpdater::getTileImage(const uint tileIndex,
  const deflect::View view) const
 {
- if (!_frameLeftOrMono)
- {
- print_log(LOG_ERROR, LOG_STREAM, "No frames yet");
- return ImagePtr();
- }
-
  // guard against frame swap during asynchronous readings
  const QReadLocker frameLock(&_frameMutex);
 
- const bool rightEye = view == deflect::View::right_eye;
- const bool rightFrame = rightEye && !_frameRight->tiles.empty();
- const auto& processor = rightFrame ? _processRight : _processorLeft;
-
- // turbojpeg handles need to be per thread, and this function may be
- // called from multiple threads
- static QThreadStorage<deflect::server::TileDecoder> tileDecoders;
  try
  {
+ if (!_frameLeftOrMono)
+ throw std::runtime_error("No frames yet");
+
+ if (tileIndex >= _perTileLock->size())
+ throw std::runtime_error("Tile index is invalid");
+
+ // prevent double-decoding of a tile that could occur unexpectedly when
+ // resizing the stream window
+ std::lock_guard<std::mutex> lock{_perTileLock->at(tileIndex)};
+
+ const bool rightEye = view == deflect::View::right_eye;
+ const bool rightFrame = rightEye && !_frameRight->tiles.empty();
+ const auto& processor = rightFrame ? _processRight : _processorLeft;
+
+ // turbojpeg handles need to be per thread, and this function may be
+ // called from multiple threads
+ static QThreadStorage<deflect::server::TileDecoder> tileDecoders;
  return processor->getTileImage(tileIndex, tileDecoders.localData());
  }
  catch (const std::runtime_error& e)
@@ -140,10 +144,8 @@ Indices PixelStreamUpdater::computeVisibleSet(const QRectF& visibleTilesArea,
  const uint channel) const
 {
  Q_UNUSED(lod);
-
  if (!_frameLeftOrMono || visibleTilesArea.isEmpty())
  return Indices{};
-
  return _processorLeft->computeVisibleSet(visibleTilesArea, channel);
 }
 
@@ -190,6 +192,7 @@ void PixelStreamUpdater::_onFrameSwapped(deflect::server::FramePtr frame)
  _frameLeftOrMono = std::move(leftOrMono);
  _frameRight = std::move(right);
  _createFrameProcessors();
+ _createPerTileMutexes();
  }
 
  emit pictureUpdated();
@@ -216,3 +219,12 @@ void PixelStreamUpdater::_createFrameProcessors()
  _processRight.reset(new PixelStreamPassthrough(_frameRight));
  }
 }
+
+void PixelStreamUpdater::_createPerTileMutexes()
+{
+ const auto tiles = (_processorLeft ? _processorLeft->getTilesCount() : 0) +
+ (_processRight ? _processRight->getTilesCount() : 0);
+
+ if (!_perTileLock || _perTileLock->size() < tiles)
+ _perTileLock = std::make_unique<std::vector<std::mutex>>(tiles);
+}

tide/wall/datasources/PixelStreamUpdater.h

@@ -113,10 +113,12 @@ class PixelStreamUpdater : public QObject, public DataSource
  std::unique_ptr<PixelStreamProcessor> _processorLeft;
  std::unique_ptr<PixelStreamProcessor> _processRight;
  mutable QReadWriteLock _frameMutex;
+ mutable std::unique_ptr<std::vector<std::mutex>> _perTileLock;
  bool _readyToSwap = true;
 
  void _onFrameSwapped(deflect::server::FramePtr frame);
  void _createFrameProcessors();
+ void _createPerTileMutexes();
 };
 
 #endif

tide/wall/tools/PixelStreamAssembler.cpp

@@ -39,6 +39,8 @@
 
 #include "PixelStreamAssembler.h"
 
+#include <numeric> // std::accumulate
+
 namespace
 {
 Indices _mapToGlobalIndices(const Indices& perChannelIndices,
@@ -58,7 +60,7 @@ PixelStreamAssembler::PixelStreamAssembler(deflect::server::FramePtr frame)
 }
 
 ImagePtr PixelStreamAssembler::getTileImage(
- uint tileIndex, deflect::server::TileDecoder& decoder)
+ const uint tileIndex, deflect::server::TileDecoder& decoder)
 {
  const auto& channel = _getChannel(tileIndex);
  return channel.assembler.getTileImage(tileIndex - channel.offset, decoder);
@@ -79,6 +81,14 @@ Indices PixelStreamAssembler::computeVisibleSet(const QRectF& visibleArea,
  return _mapToGlobalIndices(indices, channel.offset);
 }
 
+size_t PixelStreamAssembler::getTilesCount() const
+{
+ return std::accumulate(_channels.begin(), _channels.end(), 0u,
+ [](const auto count, const Channel& channel) {
+ return count + channel.tilesCount;
+ });
+}
+
 bool PixelStreamAssembler::_parseChannels(deflect::server::FramePtr frame)
 {
  if (frame->tiles.empty())

tide/wall/tools/PixelStreamAssembler.h

@@ -77,6 +77,9 @@ class PixelStreamAssembler : public PixelStreamProcessor
  Indices computeVisibleSet(const QRectF& visibleArea,
  uint channel) const final;
 
+ /** @copydoc PixelStreamProcessor::getTilesCount */
+ size_t getTilesCount() const final;
+
 private:
  struct Channel
  {

tide/wall/tools/PixelStreamChannelAssembler.cpp

@@ -130,7 +130,7 @@ Indices PixelStreamChannelAssembler::computeVisibleSet(
  return visibleSet;
 }
 
-uint PixelStreamChannelAssembler::getTilesCount() const
+size_t PixelStreamChannelAssembler::getTilesCount() const
 {
  return _getTilesX() * _getTilesY();
 }

tide/wall/tools/PixelStreamChannelAssembler.h

@@ -78,8 +78,8 @@ class PixelStreamChannelAssembler : public PixelStreamProcessor
  Indices computeVisibleSet(const QRectF& visibleArea,
  uint channel) const final;
 
- /** @return the number of tiles in the assembled image. */
- uint getTilesCount() const;
+ /** @copydoc PixelStreamProcessor::getTilesCount */
+ size_t getTilesCount() const final;
 
 private:
  deflect::server::FramePtr _frame;

tide/wall/tools/PixelStreamPassthrough.cpp

@@ -45,7 +45,7 @@
 #include <deflect/server/TileDecoder.h>
 
 PixelStreamPassthrough::PixelStreamPassthrough(deflect::server::FramePtr frame)
- : _frame(frame)
+ : _frame{std::move(frame)}
 {
 }
 
@@ -81,3 +81,8 @@ Indices PixelStreamPassthrough::computeVisibleSet(const QRectF& visibleArea,
  }
  return visibleSet;
 }
+
+size_t PixelStreamPassthrough::getTilesCount() const
+{
+ return _frame->tiles.size();
+}

tide/wall/tools/PixelStreamPassthrough.h

@@ -65,6 +65,9 @@ class PixelStreamPassthrough : public PixelStreamProcessor
  Indices computeVisibleSet(const QRectF& visibleArea,
  uint channel) const final;
 
+ /** @copydoc PixelStreamProcessor::getTilesCount */
+ size_t getTilesCount() const final;
+
 private:
  deflect::server::FramePtr _frame;
 };

tide/wall/tools/PixelStreamProcessor.h

@@ -69,6 +69,9 @@ class PixelStreamProcessor
  virtual Indices computeVisibleSet(const QRectF& visibleArea,
  uint channel) const = 0;
 
+ /** @return the total number of assembled tiles. */
+ virtual size_t getTilesCount() const = 0;
+
 protected:
  /** @return the coordinates of the tile as a QRect. */
  QRect toRect(const deflect::server::Tile& tile) const;