changeset 6849:f1066df74009 streaming

support of user data in DicomDataSource and TranscoderDataSource
author Sebastien Jodogne <s.jodogne@gmail.com>
date Fri, 22 May 2026 14:00:29 +0200
parents 68f6931f02a8
children 30879dc76b68
files OrthancFramework/Sources/DataSource/DataSourceAnswer.h OrthancFramework/Sources/DataSource/DicomDataSource.cpp OrthancFramework/Sources/DataSource/DicomDataSource.h OrthancFramework/Sources/DataSource/IDataIdentifier.h OrthancFramework/Sources/DataSource/MultipleDicomReader.cpp OrthancFramework/Sources/DataSource/StorageAreaDataSource.h OrthancFramework/Sources/DataSource/TranscoderDataSource.cpp OrthancFramework/Sources/DataSource/TranscoderDataSource.h OrthancServer/Sources/ServerContext.cpp OrthancServer/Sources/ServerTranscoder.cpp
diffstat 10 files changed, 177 insertions(+), 55 deletions(-) [+]
line wrap: on
line diff
--- a/OrthancFramework/Sources/DataSource/DataSourceAnswer.h	Fri May 22 12:17:27 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/DataSourceAnswer.h	Fri May 22 14:00:29 2026 +0200
@@ -60,6 +60,7 @@
       std::unique_ptr<OrthancException>           error_;
       boost::shared_ptr<Internals::DataSourceMemoryBudget>  budget_;
       size_t                                      memorySize_;
+      std::unique_ptr<IDynamicObject>             userData_;
 
       Item(IDataIdentifier* id /* takes ownership */,
            boost::shared_ptr<IDynamicObject>& value,
@@ -74,6 +75,16 @@
 
       const IDataIdentifier& GetId() const;
 
+      bool HasUserData() const
+      {
+        return userData_.get() != NULL;
+      }
+
+      IDynamicObject* ReleaseUserData()
+      {
+        return userData_.release();
+      }
+
       const boost::shared_ptr<IDynamicObject>& GetValue() const;
     };
 
--- a/OrthancFramework/Sources/DataSource/DicomDataSource.cpp	Fri May 22 12:17:27 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/DicomDataSource.cpp	Fri May 22 14:00:29 2026 +0200
@@ -193,6 +193,34 @@
   }
 
 
+  void DicomDataSource::Dicom::SetUserData(IDynamicObject* data)
+  {
+    std::unique_ptr<IDynamicObject> protection(data);
+
+    if (userData_.get() == NULL)
+    {
+      throw OrthancException(ErrorCode_BadSequenceOfCalls);
+    }
+    else
+    {
+      userData_.reset(data);
+    }
+  }
+
+
+  const IDynamicObject& DicomDataSource::Dicom::GetUserData()
+  {
+    if (userData_.get() == NULL)
+    {
+      throw OrthancException(ErrorCode_BadSequenceOfCalls);
+    }
+    else
+    {
+      return *userData_;
+    }
+  }
+
+
   ParsedDicomFile* DicomDataSource::Dicom::Clone()
   {
     Lock lock(*this);
@@ -206,37 +234,49 @@
   }
 
 
-  IDataIdentifier* DicomDataSource::CreateWholeIdentifier(const FileInfo& attachment)
+  IDataIdentifier* DicomDataSource::CreateWholeRequest(const FileInfo& attachment)
   {
     return new WholeIdentifier(attachment);
   }
 
 
-  DicomDataSource::Dicom* DicomDataSource::ReadWhole(DataSourceReader& reader,
-                                                     const FileInfo& attachment)
-  {
-    std::unique_ptr<IDataIdentifier> id(new WholeIdentifier(attachment));
-    boost::shared_ptr<IDynamicObject> value = reader.ReadSingle(id.release());
-    return new Dicom(value);
-  }
-
-
-  DicomDataSource::Dicom* DicomDataSource::ReadUntilPixelData(DataSourceReader& reader,
-                                                              const FileInfo& attachment,
+  IDataIdentifier* DicomDataSource::CreateUntilPixelDataRequest(const FileInfo& attachment,
                                                               uint64_t pixelDataOffset)
   {
     if (static_cast<uint64_t>(static_cast<size_t>(pixelDataOffset)) != pixelDataOffset)
     {
       throw OrthancException(ErrorCode_NotEnoughMemory);
     }
-
-    if (attachment.GetCompressionType() != CompressionType_None)
+    else if (attachment.GetCompressionType() != CompressionType_None)
     {
       throw OrthancException(ErrorCode_BadParameterType);
     }
+    else
+    {
+      return new BeginningIdentifier(attachment, static_cast<size_t>(pixelDataOffset));
+    }
+  }
 
-    std::unique_ptr<IDataIdentifier> id(new BeginningIdentifier(attachment, static_cast<size_t>(pixelDataOffset)));
-    boost::shared_ptr<IDynamicObject> value = reader.ReadSingle(id.release());
-    return new Dicom(value);
+
+  DicomDataSource::Dicom* DicomDataSource::Execute(DataSourceReader& reader,
+                                                   IDataIdentifier* request)
+  {
+    if (request == NULL)
+    {
+      throw OrthancException(ErrorCode_NullPointer);
+    }
+    else
+    {
+      std::unique_ptr<DataSourceAnswer::Item> item(reader.ReadSingleWithIdentifier(request));
+
+      std::unique_ptr<Dicom> dicom(new Dicom(item->GetValue()));
+
+      if (item->HasUserData())
+      {
+        dicom->SetUserData(item->ReleaseUserData());
+      }
+
+      return dicom.release();
+    }
   }
 }
--- a/OrthancFramework/Sources/DataSource/DicomDataSource.h	Fri May 22 12:17:27 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/DicomDataSource.h	Fri May 22 14:00:29 2026 +0200
@@ -68,9 +68,19 @@
     private:
       Mutex                              mutex_;
       boost::shared_ptr<IDynamicObject>  value_;
+      std::unique_ptr<IDynamicObject>    userData_;
 
     public:
-      explicit Dicom(const boost::shared_ptr<IDynamicObject>& value);
+      Dicom(const boost::shared_ptr<IDynamicObject>& value);
+
+      void SetUserData(IDynamicObject* data);
+
+      bool HasUserData() const
+      {
+        return userData_.get() != NULL;
+      }
+
+      const IDynamicObject& GetUserData();
 
       ParsedDicomFile* Clone();
 
@@ -96,13 +106,12 @@
       };
     };
 
-    static IDataIdentifier* CreateWholeIdentifier(const FileInfo& attachment);
+    static IDataIdentifier* CreateWholeRequest(const FileInfo& attachment);
 
-    static Dicom* ReadWhole(DataSourceReader& reader,
-                            const FileInfo& attachment);
+    static IDataIdentifier* CreateUntilPixelDataRequest(const FileInfo& attachment,
+                                                        uint64_t pixelDataOffset);
 
-    static Dicom* ReadUntilPixelData(DataSourceReader& reader,
-                                     const FileInfo& attachment,
-                                     uint64_t pixelDataOffset);
+    static Dicom* Execute(DataSourceReader& reader,
+                          IDataIdentifier* request /* takes ownership */);
   };
 }
--- a/OrthancFramework/Sources/DataSource/IDataIdentifier.h	Fri May 22 12:17:27 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/IDataIdentifier.h	Fri May 22 14:00:29 2026 +0200
@@ -45,6 +45,8 @@
 
     virtual bool HasUserData() const = 0;
 
-    virtual IDynamicObject& GetUserData() const = 0;
+    virtual const IDynamicObject& GetUserData() const = 0;
+
+    virtual IDynamicObject* ReleaseUserData() = 0;
   };
 }
--- a/OrthancFramework/Sources/DataSource/MultipleDicomReader.cpp	Fri May 22 12:17:27 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/MultipleDicomReader.cpp	Fri May 22 14:00:29 2026 +0200
@@ -55,7 +55,7 @@
       }
       else
       {
-        request_->Enqueue(DicomDataSource::CreateWholeIdentifier(attachment));
+        request_->Enqueue(DicomDataSource::CreateWholeRequest(attachment));
       }
     }
 
--- a/OrthancFramework/Sources/DataSource/StorageAreaDataSource.h	Fri May 22 12:17:27 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/StorageAreaDataSource.h	Fri May 22 14:00:29 2026 +0200
@@ -81,6 +81,7 @@
 
       void Copy(std::string& to) const;
 
+      // TODO-Streaming : Post-processing is probably an overkill
       Range* ApplyPostProcessing(const IDataIdentifier& identifier) const;
 
       static Range* CreateFromSwap(std::string& content);
--- a/OrthancFramework/Sources/DataSource/TranscoderDataSource.cpp	Fri May 22 12:17:27 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/TranscoderDataSource.cpp	Fri May 22 14:00:29 2026 +0200
@@ -252,6 +252,34 @@
   }
 
 
+  void TranscoderDataSource::Transcoded::SetUserData(IDynamicObject* data)
+  {
+    std::unique_ptr<IDynamicObject> protection(data);
+
+    if (userData_.get() == NULL)
+    {
+      throw OrthancException(ErrorCode_BadSequenceOfCalls);
+    }
+    else
+    {
+      userData_.reset(data);
+    }
+  }
+
+
+  const IDynamicObject& TranscoderDataSource::Transcoded::GetUserData()
+  {
+    if (userData_.get() == NULL)
+    {
+      throw OrthancException(ErrorCode_BadSequenceOfCalls);
+    }
+    else
+    {
+      return *userData_;
+    }
+  }
+
+
   TranscoderDataSource::Transcoded::LockAsParsed::LockAsParsed(Transcoded& that) :
     lock_(that.mutex_)
   {
@@ -297,27 +325,44 @@
   }
 
 
-  TranscoderDataSource::Transcoded* TranscoderDataSource::Transcode(DataSourceReader& reader,
-                                                                    const FileInfo& attachment,
-                                                                    DicomTransferSyntax targetSyntax)
+  IDataIdentifier* TranscoderDataSource::CreateRequest(const FileInfo& attachment,
+                                                       DicomTransferSyntax targetSyntax)
   {
-    std::unique_ptr<IDataIdentifier> id(new Identifier(attachment, targetSyntax));
-    boost::shared_ptr<IDynamicObject> value = reader.ReadSingle(id.release());
-    return new Transcoded(value);
+    return new Identifier(attachment, targetSyntax);
   }
 
 
-  TranscoderDataSource::Transcoded* TranscoderDataSource::Transcode(DataSourceReader& reader,
-                                                                    const FileInfo& attachment,
-                                                                    DicomTransferSyntax targetSyntax,
-                                                                    TranscodingSopInstanceUidMode mode,
-                                                                    unsigned int lossyQuality)
+  IDataIdentifier* TranscoderDataSource::CreateRequest(const FileInfo& attachment,
+                                                       DicomTransferSyntax targetSyntax,
+                                                       TranscodingSopInstanceUidMode mode,
+                                                       unsigned int lossyQuality)
   {
     std::unique_ptr<Identifier> id(new Identifier(attachment, targetSyntax));
     id->SetMode(mode);
     id->SetLossyQuality(lossyQuality);
+    return id.release();
+  }
 
-    boost::shared_ptr<IDynamicObject> value = reader.ReadSingle(id.release());
-    return new Transcoded(value);
+
+  TranscoderDataSource::Transcoded* TranscoderDataSource::Execute(DataSourceReader& reader,
+                                                                  IDataIdentifier* request)
+  {
+    if (request == NULL)
+    {
+      throw OrthancException(ErrorCode_NullPointer);
+    }
+    else
+    {
+      std::unique_ptr<DataSourceAnswer::Item> item(reader.ReadSingleWithIdentifier(request));
+
+      std::unique_ptr<Transcoded> transcoded(new Transcoded(item->GetValue()));
+
+      if (item->HasUserData())
+      {
+        transcoded->SetUserData(item->ReleaseUserData());
+      }
+
+      return transcoded.release();
+    }
   }
 }
--- a/OrthancFramework/Sources/DataSource/TranscoderDataSource.h	Fri May 22 12:17:27 2026 +0200
+++ b/OrthancFramework/Sources/DataSource/TranscoderDataSource.h	Fri May 22 14:00:29 2026 +0200
@@ -57,10 +57,20 @@
     private:
       Mutex                              mutex_;
       boost::shared_ptr<IDynamicObject>  value_;
+      std::unique_ptr<IDynamicObject>    userData_;
 
     public:
       explicit Transcoded(const boost::shared_ptr<IDynamicObject>& value);
 
+      void SetUserData(IDynamicObject* data);
+
+      bool HasUserData() const
+      {
+        return userData_.get() != NULL;
+      }
+
+      const IDynamicObject& GetUserData();
+
       class LockAsParsed : public boost::noncopyable
       {
       private:
@@ -104,14 +114,15 @@
       };
     };
 
-    static Transcoded* Transcode(DataSourceReader& reader,
-                                 const FileInfo& attachment,
-                                 DicomTransferSyntax targetSyntax);
+    static IDataIdentifier* CreateRequest(const FileInfo& attachment,
+                                          DicomTransferSyntax targetSyntax);
 
-    static Transcoded* Transcode(DataSourceReader& reader,
-                                 const FileInfo& attachment,
-                                 DicomTransferSyntax targetSyntax,
-                                 TranscodingSopInstanceUidMode mode,
-                                 unsigned int lossyQuality);
+    static IDataIdentifier* CreateRequest(const FileInfo& attachment,
+                                          DicomTransferSyntax targetSyntax,
+                                          TranscodingSopInstanceUidMode mode,
+                                          unsigned int lossyQuality);
+
+    static Transcoded* Execute(DataSourceReader& reader,
+                               IDataIdentifier* request /* takes ownership */);
   };
 }
--- a/OrthancServer/Sources/ServerContext.cpp	Fri May 22 12:17:27 2026 +0200
+++ b/OrthancServer/Sources/ServerContext.cpp	Fri May 22 14:00:29 2026 +0200
@@ -1320,7 +1320,8 @@
 
     if (LookupAttachment(attachment, FileContentType_DicomUntilPixelData, instanceAttachments))
     {
-      std::unique_ptr<DicomDataSource::Dicom> dicom(DicomDataSource::ReadWhole(*dicomReader_, attachment));
+      std::unique_ptr<DicomDataSource::Dicom> dicom(
+        DicomDataSource::Execute(*dicomReader_, DicomDataSource::CreateWholeRequest(attachment)));
 
       {
         DicomDataSource::Dicom::Lock lock(*dicom);
@@ -1369,7 +1370,7 @@
          **/
 
         std::unique_ptr<DicomDataSource::Dicom> dicom(
-          DicomDataSource::ReadUntilPixelData(*dicomReader_, attachment, pixelDataOffset));
+          DicomDataSource::Execute(*dicomReader_, DicomDataSource::CreateUntilPixelDataRequest(attachment, pixelDataOffset)));
 
         {
           DicomDataSource::Dicom::Lock lock(*dicom);
@@ -1500,7 +1501,7 @@
 
   DicomDataSource::Dicom* ServerContext::ReadParsedDicom(const std::string& instancePublicId)
   {
-    return DicomDataSource::ReadWhole(*dicomReader_, LookupDicomForInstance(instancePublicId));
+    return DicomDataSource::Execute(*dicomReader_, DicomDataSource::CreateWholeRequest(LookupDicomForInstance(instancePublicId)));
   }
 
 
@@ -1512,7 +1513,7 @@
     if (index_.LookupAttachment(attachment, revision, ResourceType_Instance,
                                 instancePublicId, FileContentType_DicomUntilPixelData))
     {
-      return DicomDataSource::ReadWhole(*dicomReader_, attachment);
+      return DicomDataSource::Execute(*dicomReader_, DicomDataSource::CreateWholeRequest(attachment));
     }
     else
     {
@@ -1529,7 +1530,7 @@
 
         if (SerializationToolbox::ParseUnsignedInteger64(pixelDataOffset, metadata))
         {
-          return DicomDataSource::ReadUntilPixelData(*dicomReader_, attachment, pixelDataOffset);
+          return DicomDataSource::Execute(*dicomReader_, DicomDataSource::CreateUntilPixelDataRequest(attachment, pixelDataOffset));
         }
         else
         {
@@ -1538,7 +1539,7 @@
       }
 
       // Fallback: The pixel data offset is not present or cannot be used, the whole DICOM file must be read
-      return DicomDataSource::ReadWhole(*dicomReader_, attachment);
+      return DicomDataSource::Execute(*dicomReader_, DicomDataSource::CreateWholeRequest(attachment));
     }
   }
 
--- a/OrthancServer/Sources/ServerTranscoder.cpp	Fri May 22 12:17:27 2026 +0200
+++ b/OrthancServer/Sources/ServerTranscoder.cpp	Fri May 22 14:00:29 2026 +0200
@@ -239,7 +239,8 @@
                                                       const FileInfo& attachment,
                                                       unsigned int frameIndex)
   {
-    std::unique_ptr<DicomDataSource::Dicom> dicom(DicomDataSource::ReadWhole(*dicomReader, attachment));
+    std::unique_ptr<DicomDataSource::Dicom> dicom(
+      DicomDataSource::Execute(*dicomReader, DicomDataSource::CreateWholeRequest(attachment)));
 
     DicomDataSource::Dicom::Lock lock(*dicom);
 
@@ -276,7 +277,8 @@
     else
     {
       std::unique_ptr<TranscoderDataSource::Transcoded> transcoded(
-        TranscoderDataSource::Transcode(*transcoderReader, attachment, DicomTransferSyntax_LittleEndianExplicit));
+        TranscoderDataSource::Execute(
+          *transcoderReader, TranscoderDataSource::CreateRequest(attachment, DicomTransferSyntax_LittleEndianExplicit)));
 
       TranscoderDataSource::Transcoded::LockAsParsed lock(*transcoded);