changeset 6870:e48f923cdab8 streaming

propagation of user data until DicomSequentialReader
author Sebastien Jodogne <s.jodogne@gmail.com>
date Tue, 26 May 2026 21:36:47 +0200
parents 874a093dd254
children c6830eae8586
files OrthancFramework/Sources/DataSource/BaseDataIdentifier.cpp OrthancFramework/Sources/DataSource/BaseDataIdentifier.h OrthancFramework/Sources/DataSource/DataSourceAnswer.cpp OrthancFramework/Sources/DataSource/DataSourceAnswer.h OrthancFramework/Sources/DataSource/DataSourceSequentialReader.cpp OrthancFramework/Sources/DataSource/DataSourceSequentialReader.h OrthancFramework/Sources/DataSource/DicomSequentialReader.cpp OrthancFramework/Sources/DataSource/DicomSequentialReader.h OrthancFramework/Sources/DataSource/IDataIdentifier.h OrthancServer/Sources/OrthancGetRequestHandler.cpp OrthancServer/Sources/ServerContext.cpp OrthancServer/Sources/ServerContext.h OrthancServer/Sources/ServerJobs/ArchiveJob.cpp
diffstat 13 files changed, 231 insertions(+), 66 deletions(-) [+]
line wrap: on
line diff
--- a/OrthancFramework/Sources/DataSource/BaseDataIdentifier.cpp	Tue May 26 18:41:02 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/BaseDataIdentifier.cpp	Tue May 26 21:36:47 2026 +0200
@@ -62,4 +62,17 @@
       throw OrthancException(ErrorCode_BadSequenceOfCalls);
     }
   }
+
+
+  IDynamicObject* BaseDataIdentifier::ReleaseUserData()
+  {
+    if (userData_.get() != NULL)
+    {
+      return userData_.release();
+    }
+    else
+    {
+      throw OrthancException(ErrorCode_BadSequenceOfCalls);
+    }
+  }
 }
--- a/OrthancFramework/Sources/DataSource/BaseDataIdentifier.h	Tue May 26 18:41:02 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/BaseDataIdentifier.h	Tue May 26 21:36:47 2026 +0200
@@ -41,5 +41,7 @@
     virtual bool HasUserData() const ORTHANC_OVERRIDE;
 
     virtual const IDynamicObject& GetUserData() const ORTHANC_OVERRIDE;
+
+    virtual IDynamicObject* ReleaseUserData() ORTHANC_OVERRIDE;
   };
 }
--- a/OrthancFramework/Sources/DataSource/DataSourceAnswer.cpp	Tue May 26 18:41:02 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/DataSourceAnswer.cpp	Tue May 26 21:36:47 2026 +0200
@@ -103,19 +103,6 @@
   }
 
 
-  IDataIdentifier* DataSourceAnswer::Item::ReleaseIdentifier()
-  {
-    if (id_.get() == NULL)
-    {
-      throw OrthancException(ErrorCode_BadSequenceOfCalls);
-    }
-    else
-    {
-      return id_.release();
-    }
-  }
-
-
   void DataSourceAnswer::EnqueueInternal(Item* item)
   {
     std::unique_ptr<Item> protection(item);
--- a/OrthancFramework/Sources/DataSource/DataSourceAnswer.h	Tue May 26 18:41:02 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/DataSourceAnswer.h	Tue May 26 21:36:47 2026 +0200
@@ -76,7 +76,15 @@
 
       const boost::shared_ptr<IDynamicObject>& GetValue() const;
 
-      IDataIdentifier* ReleaseIdentifier();
+      bool HasUserData() const
+      {
+        return id_->HasUserData();
+      }
+
+      IDynamicObject* ReleaseUserData()
+      {
+        return id_->ReleaseUserData();
+      }
     };
 
   private:
--- a/OrthancFramework/Sources/DataSource/DataSourceSequentialReader.cpp	Tue May 26 18:41:02 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/DataSourceSequentialReader.cpp	Tue May 26 21:36:47 2026 +0200
@@ -30,38 +30,22 @@
 
 namespace Orthanc
 {
-  DataSourceSequentialReader::Item::Item(IDataIdentifier* id,
-                                         IDynamicObject* value,
+  DataSourceSequentialReader::Item::Item(IDynamicObject* value,
                                          size_t estimatedSize) :
-    id_(id),
     value_(value),
     estimatedSize_(estimatedSize)
   {
-    if (id == NULL ||
-        value == NULL)
+    if (value == NULL)
     {
       throw OrthancException(ErrorCode_NullPointer);
     }
   }
 
 
-  DataSourceSequentialReader::Item::Item(IDataIdentifier* id,
-                                         const OrthancException& error) :
-    id_(id),
+  DataSourceSequentialReader::Item::Item(const OrthancException& error) :
     error_(new OrthancException(error)),
     estimatedSize_(0)
   {
-    if (id == NULL)
-    {
-      throw OrthancException(ErrorCode_NullPointer);
-    }
-  }
-
-
-  const IDataIdentifier& DataSourceSequentialReader::Item::GetIdentifier() const
-  {
-    assert(id_.get() != NULL);
-    return *id_;
   }
 
 
@@ -83,6 +67,32 @@
   }
 
 
+  void DataSourceSequentialReader::Item::SetUserData(IDynamicObject* userData)
+  {
+    if (userData == NULL)
+    {
+      throw OrthancException(ErrorCode_NullPointer);
+    }
+    else
+    {
+      userData_.reset(userData);
+    }
+  }
+
+
+  const IDynamicObject& DataSourceSequentialReader::Item::GetUserData() const
+  {
+    if (userData_.get() == NULL)
+    {
+      throw OrthancException(ErrorCode_BadSequenceOfCalls);
+    }
+    else
+    {
+      return *userData_;
+    }
+  }
+
+
   IDynamicObject* DataSourceSequentialReader::Item::ReleaseValue()
   {
     if (value_.get() != NULL)
@@ -101,6 +111,19 @@
   }
 
 
+  IDynamicObject* DataSourceSequentialReader::Item::ReleaseUserData()
+  {
+    if (userData_.get() == NULL)
+    {
+      throw OrthancException(ErrorCode_BadSequenceOfCalls);
+    }
+    else
+    {
+      return userData_.release();
+    }
+  }
+
+
   class DataSourceSequentialReader::Callable : public ICallable
   {
   private:
@@ -131,18 +154,40 @@
     {
       std::unique_ptr<DataSourceAnswer::Item> answer(reader_->ReadSingle(request_.release()));
 
+      std::unique_ptr<IDynamicObject> userData;
+
+      if (answer->HasUserData())
+      {
+        userData.reset(answer->ReleaseUserData());
+      }
+
+      std::unique_ptr<Item> item;
+
       try
       {
-        return new Item(answer->ReleaseIdentifier(), disconnector_->Apply(answer.release()), estimatedSize_);
+        std::unique_ptr<IDynamicObject> detached(disconnector_->Apply(answer.release()));
+        if (detached.get() == NULL)
+        {
+          throw OrthancException(ErrorCode_NullPointer);
+        }
+
+        item.reset(new Item(detached.release(), estimatedSize_));
       }
       catch (OrthancException& e)
       {
-        return new Item(answer->ReleaseIdentifier(), e);
+        item.reset(new Item(e));
       }
       catch (...)
       {
-        return new Item(answer->ReleaseIdentifier(), OrthancException(ErrorCode_InternalError));
+        item.reset(new Item(OrthancException(ErrorCode_InternalError)));
       }
+
+      if (userData.get() != NULL)
+      {
+        item->SetUserData(userData.release());
+      }
+
+      return item.release();
     }
   };
 
--- a/OrthancFramework/Sources/DataSource/DataSourceSequentialReader.h	Tue May 26 18:41:02 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/DataSourceSequentialReader.h	Tue May 26 21:36:47 2026 +0200
@@ -54,29 +54,36 @@
     class Item : public IDynamicObject
     {
     private:
-      std::unique_ptr<IDataIdentifier>   id_;
       std::unique_ptr<IDynamicObject>    value_;
       std::unique_ptr<OrthancException>  error_;
+      std::unique_ptr<IDynamicObject>    userData_;
       size_t                             estimatedSize_;
 
     public:
-      Item(IDataIdentifier* id,
-           IDynamicObject* value,
+      Item(IDynamicObject* value,
            size_t estimatedSize);
 
-      Item(IDataIdentifier* id,
-           const OrthancException& error);
-
-      const IDataIdentifier& GetIdentifier() const;
+      Item(const OrthancException& error);
 
       const IDynamicObject& GetValue() const;
 
+      void SetUserData(IDynamicObject* userData);
+
+      bool HasUserData() const
+      {
+        return userData_.get() != NULL;
+      }
+
+      const IDynamicObject& GetUserData() const;
+
       size_t GetEstimatedSize() const
       {
         return estimatedSize_;
       }
 
       IDynamicObject* ReleaseValue();
+
+      IDynamicObject* ReleaseUserData();
     };
 
 
@@ -92,6 +99,7 @@
       {
       }
 
+      // Note that "source" will never contain user data, those are handled at the level above
       virtual IDynamicObject* Apply(DataSourceAnswer::Item* source) = 0;
     };
 
--- a/OrthancFramework/Sources/DataSource/DicomSequentialReader.cpp	Tue May 26 18:41:02 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/DicomSequentialReader.cpp	Tue May 26 21:36:47 2026 +0200
@@ -108,6 +108,32 @@
   }
 
 
+  void DicomSequentialReader::Item::SetUserData(IDynamicObject* userData /* takes ownership */)
+  {
+    if (userData == NULL)
+    {
+      throw OrthancException(ErrorCode_NullPointer);
+    }
+    else
+    {
+      userData_.reset(userData);
+    }
+  }
+
+
+  const IDynamicObject& DicomSequentialReader::Item::GetUserData() const
+  {
+    if (userData_.get() == NULL)
+    {
+      throw OrthancException(ErrorCode_BadSequenceOfCalls);
+    }
+    else
+    {
+      return *userData_;
+    }
+  }
+
+
   class DicomSequentialReader::Disconnector : public DataSourceSequentialReader::IValueDisconnector
   {
   private:
@@ -119,7 +145,7 @@
     {
     }
 
-    virtual IDynamicObject* Apply(DataSourceAnswer::Item* source)
+    virtual IDynamicObject* Apply(DataSourceAnswer::Item* source) ORTHANC_OVERRIDE
     {
       std::unique_ptr<DataSourceAnswer::Item> protection(source);
 
@@ -205,19 +231,35 @@
 
 
   DicomSequentialReader* DicomSequentialReader::CreateForOriginal(const boost::shared_ptr<IExecutorService>& executor,
+                                                                  ExpectedAnswer expectedAnswer,
                                                                   const boost::shared_ptr<DataSourceReader>& dicomReader,
                                                                   unsigned int windowSize,
                                                                   uint64_t windowCapacity)
   {
-    return new DicomSequentialReader(
-      SourceType_Dicom, executor,
-      DicomTransferSyntax_LittleEndianImplicit, TranscodingSopInstanceUidMode_AllowNew,
-      false /* no lossy */, 0 /* unused lossy quality */,
-      dicomReader, windowSize, windowCapacity);
+    switch (expectedAnswer)
+    {
+      case ExpectedAnswer_ParsedDicomFile:
+        return new DicomSequentialReader(
+          SourceType_Dicom, executor,
+          DicomTransferSyntax_LittleEndianImplicit, TranscodingSopInstanceUidMode_AllowNew,  /* dummy values */
+          false /* no lossy */, 0 /* unused lossy quality */,
+          dicomReader, windowSize, windowCapacity);
+
+      case ExpectedAnswer_RawMemoryBuffer:
+        return new DicomSequentialReader(
+          SourceType_StorageArea, executor,
+          DicomTransferSyntax_LittleEndianImplicit, TranscodingSopInstanceUidMode_AllowNew,  /* dummy values */
+          false /* no lossy */, 0 /* unused lossy quality */,
+          dicomReader, windowSize, windowCapacity);
+
+      default:
+        throw OrthancException(ErrorCode_NotImplemented);
+    }
   }
 
 
   DicomSequentialReader* DicomSequentialReader::CreateForTranscoded(const boost::shared_ptr<IExecutorService>& executor,
+                                                                    ExpectedAnswer expectedAnswer,
                                                                     DicomTransferSyntax targetSyntax,
                                                                     TranscodingSopInstanceUidMode mode,
                                                                     bool hasLossyQuality,
@@ -226,10 +268,20 @@
                                                                     unsigned int windowSize,
                                                                     uint64_t windowCapacity)
   {
-    return new DicomSequentialReader(
-      SourceType_Transcoder, executor,
-      targetSyntax, mode, hasLossyQuality, lossyQuality,
-      transcoderReader, windowSize, windowCapacity);
+    switch (expectedAnswer)
+    {
+      case ExpectedAnswer_RawMemoryBuffer:
+        // TODO
+
+      case ExpectedAnswer_ParsedDicomFile:
+        return new DicomSequentialReader(
+          SourceType_Transcoder, executor,
+          targetSyntax, mode, hasLossyQuality, lossyQuality,
+          transcoderReader, windowSize, windowCapacity);
+
+      default:
+        throw OrthancException(ErrorCode_NotImplemented);
+    }
   }
 
 
@@ -265,7 +317,15 @@
 
   DicomSequentialReader::Item* DicomSequentialReader::Next()
   {
-    std::unique_ptr<DataSourceSequentialReader::Item> item(reader_.Next());
-    return dynamic_cast<Item*>(item->ReleaseValue());
+    std::unique_ptr<DataSourceSequentialReader::Item> source(reader_.Next());
+
+    std::unique_ptr<Item> target(dynamic_cast<Item*>(source->ReleaseValue()));
+
+    if (source->HasUserData())
+    {
+      target->SetUserData(source->ReleaseUserData());
+    }
+
+    return target.release();
   }
 }
--- a/OrthancFramework/Sources/DataSource/DicomSequentialReader.h	Tue May 26 18:41:02 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/DicomSequentialReader.h	Tue May 26 21:36:47 2026 +0200
@@ -37,25 +37,39 @@
   class ORTHANC_PUBLIC DicomSequentialReader : public boost::noncopyable
   {
   public:
+    enum ExpectedAnswer
+    {
+      ExpectedAnswer_ParsedDicomFile,
+      ExpectedAnswer_RawMemoryBuffer
+    };
+
     class ORTHANC_PUBLIC Item : public IDynamicObject
     {
     private:
       std::unique_ptr<ParsedDicomFile>  parsed_;
       boost::shared_ptr<IMemoryBuffer>  raw_;
+      std::unique_ptr<IDynamicObject>   userData_;
 
     public:
       explicit Item(ParsedDicomFile* parsed /* takes ownership */);
 
       explicit Item(const boost::shared_ptr<IMemoryBuffer>& raw);
 
-    private:
       Item(ParsedDicomFile* parsed /* takes ownership */,
            IMemoryBuffer* raw /* takes ownership */);
 
-    public:
       ParsedDicomFile& GetParsedDicomFile();
 
       const IMemoryBuffer& GetRawMemoryBuffer();
+
+      void SetUserData(IDynamicObject* userData /* takes ownership */);
+
+      bool HasUserData() const
+      {
+        return userData_.get() != NULL;
+      }
+
+      const IDynamicObject& GetUserData() const;
     };
 
   private:
@@ -90,11 +104,13 @@
 
   public:
     static DicomSequentialReader* CreateForOriginal(const boost::shared_ptr<IExecutorService>& executor,
+                                                    ExpectedAnswer expectedAnswer,
                                                     const boost::shared_ptr<DataSourceReader>& dicomReader,
                                                     unsigned int windowSize,
                                                     uint64_t windowCapacity);
 
     static DicomSequentialReader* CreateForTranscoded(const boost::shared_ptr<IExecutorService>& executor,
+                                                      ExpectedAnswer expectedAnswer,
                                                       DicomTransferSyntax targetSyntax,
                                                       TranscodingSopInstanceUidMode mode,
                                                       bool hasLossyQuality,
--- a/OrthancFramework/Sources/DataSource/IDataIdentifier.h	Tue May 26 18:41:02 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/IDataIdentifier.h	Tue May 26 21:36:47 2026 +0200
@@ -46,5 +46,7 @@
     virtual bool HasUserData() const = 0;
 
     virtual const IDynamicObject& GetUserData() const = 0;
+
+    virtual IDynamicObject* ReleaseUserData() = 0;
   };
 }
--- a/OrthancServer/Sources/OrthancGetRequestHandler.cpp	Tue May 26 18:41:02 2026 +0200
+++ b/OrthancServer/Sources/OrthancGetRequestHandler.cpp	Tue May 26 21:36:47 2026 +0200
@@ -588,7 +588,7 @@
     }
 
 
-    instancesLoader_.reset(context_.CreateDicomSequentialReader());
+    instancesLoader_.reset(context_.CreateDicomSequentialReader(true /* we want ParsedDicomFile */));
 
     for (size_t i = 0; i < instancesIds_.size(); ++i)
     {
--- a/OrthancServer/Sources/ServerContext.cpp	Tue May 26 18:41:02 2026 +0200
+++ b/OrthancServer/Sources/ServerContext.cpp	Tue May 26 21:36:47 2026 +0200
@@ -2172,22 +2172,38 @@
   }
 
 
-  DicomSequentialReader* ServerContext::CreateDicomSequentialReader()
+  static DicomSequentialReader::ExpectedAnswer ConvertToExpectedAnswer(bool asParsedDicomFile)
+  {
+    if (asParsedDicomFile)
+    {
+      return DicomSequentialReader::ExpectedAnswer_ParsedDicomFile;
+    }
+    else
+    {
+      return DicomSequentialReader::ExpectedAnswer_RawMemoryBuffer;
+    }
+  }
+
+
+  DicomSequentialReader* ServerContext::CreateDicomSequentialReader(bool asParsedDicomFile)
   {
     return DicomSequentialReader::CreateForOriginal(
-      sequentialReaderThreadPool_, dicomReader_,
+      sequentialReaderThreadPool_, ConvertToExpectedAnswer(asParsedDicomFile),
+      asParsedDicomFile ? dicomReader_ : storageAreaReader_,
       4 /* TODO-Streaming: Parameter */,
       0  /* TODO-Streaming: Parameter */);
   }
 
 
-  DicomSequentialReader* ServerContext::CreateTranscodedSequentialReader(DicomTransferSyntax targetSyntax,
+  DicomSequentialReader* ServerContext::CreateTranscodedSequentialReader(bool asParsedDicomFile,
+                                                                         DicomTransferSyntax targetSyntax,
                                                                          TranscodingSopInstanceUidMode mode,
                                                                          bool hasLossyQuality,
                                                                          unsigned int lossyQuality)
   {
     return DicomSequentialReader::CreateForTranscoded(
-      sequentialReaderThreadPool_, targetSyntax, mode, hasLossyQuality, lossyQuality, transcoderReader_,
+      sequentialReaderThreadPool_, ConvertToExpectedAnswer(asParsedDicomFile),
+      targetSyntax, mode, hasLossyQuality, lossyQuality, transcoderReader_,
       4 /* TODO-Streaming: Parameter */,
       0  /* TODO-Streaming: Parameter */);
   }
--- a/OrthancServer/Sources/ServerContext.h	Tue May 26 18:41:02 2026 +0200
+++ b/OrthancServer/Sources/ServerContext.h	Tue May 26 21:36:47 2026 +0200
@@ -593,9 +593,16 @@
 
     Future* SubmitTranscodingRequest(TranscodingCallable* callable);
 
-    DicomSequentialReader* CreateDicomSequentialReader();
+    /**
+     * If "asParsedDicomFile" is "false", the reader will prioritize
+     * the downloading of the raw DICOM files (and avoid parsing if
+     * possible). If it is "true", the reader will prioritize the
+     * parsing of the DICOM files.
+     **/
+    DicomSequentialReader* CreateDicomSequentialReader(bool asParsedDicomFile);
 
-    DicomSequentialReader* CreateTranscodedSequentialReader(DicomTransferSyntax targetSyntax,
+    DicomSequentialReader* CreateTranscodedSequentialReader(bool asParsedDicomFile,
+                                                            DicomTransferSyntax targetSyntax,
                                                             TranscodingSopInstanceUidMode mode,
                                                             bool hasLossyQuality,
                                                             unsigned int lossyQuality);
--- a/OrthancServer/Sources/ServerJobs/ArchiveJob.cpp	Tue May 26 18:41:02 2026 +0200
+++ b/OrthancServer/Sources/ServerJobs/ArchiveJob.cpp	Tue May 26 21:36:47 2026 +0200
@@ -1204,11 +1204,12 @@
       if (transcode_)
       {
         instancesLoader_.reset(context_.CreateTranscodedSequentialReader(
-                                 transferSyntax_, TranscodingSopInstanceUidMode_AllowNew, hasLossyQuality_, lossyQuality_));
+                                 false /* prioritize raw DICOM files */, transferSyntax_,
+                                 TranscodingSopInstanceUidMode_AllowNew, hasLossyQuality_, lossyQuality_));
       }
       else
       {
-        instancesLoader_.reset(context_.CreateDicomSequentialReader());
+        instancesLoader_.reset(context_.CreateDicomSequentialReader(false /* prioritize raw DICOM files */));
       }
 
       writer_->PreloadAllCommands(*instancesLoader_);