Merge pull request #21 from darbyjohnston/otioz_mmap2

Memory-map support for .otioz

Author: darbyjohnston

bin/toucan-render/App.cpp

@@ -7,7 +7,7 @@
 
 #include <toucan/ImageEffectHost.h>
 #include <toucan/ImageGraph.h>
-#include <toucan/Timeline.h>
+#include <toucan/TimelineWrapper.h>
 #include <toucan/Util.h>
 
 #include <OpenImageIO/imagebufalgo.h>
@@ -148,10 +148,10 @@ namespace toucan
         const size_t outputNumberPadding = getNumberPadding(outputSplit.second);
 
         // Open the timeline.
-        auto timeline = std::make_shared<Timeline>(inputPath);
+        auto timelineWrapper = std::make_shared<TimelineWrapper>(inputPath);
 
         // Get time values.
-        const OTIO_NS::TimeRange& timeRange = timeline->getTimeRange();
+        const OTIO_NS::TimeRange& timeRange = timelineWrapper->getTimeRange();
         const OTIO_NS::RationalTime timeInc(1.0, timeRange.duration().rate());
         const int frames = timeRange.duration().value();
 
@@ -165,7 +165,7 @@ namespace toucan
         imageGraphOptions.log = log;
         const auto graph = std::make_shared<ImageGraph>(
             inputPath.parent_path(),
-            timeline,
+            timelineWrapper,
             imageGraphOptions);
         const IMATH_NAMESPACE::V2d imageSize = graph->getImageSize();
 
@@ -245,13 +245,13 @@ namespace toucan
                 {
                     if (!_args.outputRaw)
                     {
-                        const std::filesystem::path path = getSequenceFrame(
-                            outputPath.parent_path(),
+                        const std::string fileName = getSequenceFrame(
+                            outputPath.parent_path().string(),
                             outputSplit.first,
                             outputStartFrame + time.to_frames(),
                             outputNumberPadding,
                             outputPath.extension().string());
-                        buf.write(path.string());
+                        buf.write(fileName);
                     }
                     else
                     {
@@ -278,14 +278,14 @@ namespace toucan
                 // Write the graph.
                 if (_options.graph)
                 {
-                    const std::filesystem::path path = getSequenceFrame(
-                        outputPath.parent_path(),
+                    const std::string fileName = getSequenceFrame(
+                        outputPath.parent_path().string(),
                         outputSplit.first,
                         outputStartFrame + time.to_frames(),
                         outputNumberPadding,
                         ".dot");
                     const std::vector<std::string> lines = node->graph(inputPath.stem().string());
-                    if (FILE* f = fopen(path.string().c_str(), "w"))
+                    if (FILE* f = fopen(fileName.c_str(), "w"))
                     {
                         for (const auto& line : lines)
                         {

lib/toucan/CMakeLists.txt

@@ -5,12 +5,13 @@ set(HEADERS
     ImageEffectHost.h
     ImageGraph.h
     ImageNode.h
+    MemoryMap.h
     MessageLog.h
     Plugin.h
     PropertySet.h
     Read.h
     TimeWarp.h
-    Timeline.h
+    TimelineWrapper.h
     Util.h)
 set(HEADERS_PRIVATE
     ImageEffect_p.h)
@@ -21,19 +22,22 @@ set(SOURCE
     ImageEffectHost.cpp
     ImageGraph.cpp
     ImageNode.cpp
+    MemoryMap.cpp
     MessageLog.cpp
     Plugin.cpp
     PropertySet.cpp
     Read.cpp
     TimeWarp.cpp
-    Timeline.cpp
+    TimelineWrapper.cpp
     Util.cpp)
 if(WIN32)
     list(APPEND SOURCE
+        MemoryMapWin32.cpp
         PluginWin32.cpp
         UtilWin32.cpp)
 else()
     list(APPEND SOURCE
+        MemoryMapUnix.cpp
         PluginUnix.cpp
         UtilUnix.cpp)
 endif()

lib/toucan/FFmpegRead.cpp

@@ -18,6 +18,8 @@ namespace toucan
 {
     namespace
     {
+        const size_t avIOContextBufferSize = 4096;
+
         void logCallback(void*, int level, const char* fmt, va_list vl)
         {
             switch (level)
@@ -70,13 +72,44 @@ namespace toucan
         }
     }
 
-    FFmpegRead::FFmpegRead(const std::filesystem::path& path) :
-        _path(path)
+    FFmpegRead::FFmpegRead(
+        const std::filesystem::path& path,
+        const MemoryReference& memoryReference) :
+        _path(path),
+        _memoryReference(memoryReference)
     {
         av_log_set_level(AV_LOG_QUIET);
         //av_log_set_level(AV_LOG_VERBOSE);
         //av_log_set_callback(logCallback);
 
+        if (memoryReference.isValid())
+        {
+            _avFormatContext = avformat_alloc_context();
+            if (!_avFormatContext)
+            {
+                throw std::runtime_error("Cannot allocate format context");
+            }
+
+            _avIOBufferData = AVIOBufferData(
+                reinterpret_cast<const uint8_t*>(memoryReference.getData()),
+                memoryReference.getSize());
+            _avIOContextBuffer = static_cast<uint8_t*>(av_malloc(avIOContextBufferSize));
+            _avIOContext = avio_alloc_context(
+                _avIOContextBuffer,
+                avIOContextBufferSize,
+                0,
+                &_avIOBufferData,
+                &_avIOBufferRead,
+                nullptr,
+                &_avIOBufferSeek);
+            if (!_avIOContext)
+            {
+                throw std::runtime_error("Cannot allocate I/O context");
+            }
+
+            _avFormatContext->pb = _avIOContext;
+        }
+
         const std::string fileName = path.string();
         int r = avformat_open_input(
             &_avFormatContext,
@@ -578,4 +611,49 @@ namespace toucan
         }
         return out;
     }
+
+    FFmpegRead::AVIOBufferData::AVIOBufferData()
+    {}
+
+    FFmpegRead::AVIOBufferData::AVIOBufferData(const uint8_t* data, size_t size) :
+        data(data),
+        size(size)
+    {}
+
+    int FFmpegRead::_avIOBufferRead(void* opaque, uint8_t* buf, int bufSize)
+    {
+        AVIOBufferData* bufferData = static_cast<AVIOBufferData*>(opaque);
+
+        const int64_t remaining = bufferData->size - bufferData->offset;
+        int bufSizeClamped = std::min(std::max(
+            static_cast<int64_t>(bufSize),
+            static_cast<int64_t>(0)),
+            remaining);
+        if (!bufSizeClamped)
+        {
+            return AVERROR_EOF;
+        }
+
+        memcpy(buf, bufferData->data + bufferData->offset, bufSizeClamped);
+        bufferData->offset += bufSizeClamped;
+
+        return bufSizeClamped;
+    }
+
+    int64_t FFmpegRead::_avIOBufferSeek(void* opaque, int64_t offset, int whence)
+    {
+        AVIOBufferData* bufferData = static_cast<AVIOBufferData*>(opaque);
+
+        if (whence & AVSEEK_SIZE)
+        {
+            return bufferData->size;
+        }
+
+        bufferData->offset = std::min(std::max(
+            offset,
+            static_cast<int64_t>(0)),
+            static_cast<int64_t>(bufferData->size));
+
+        return offset;
+    }
 }

lib/toucan/FFmpegRead.h

@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include "MemoryMap.h"
+
 #include <opentimelineio/anyVector.h>
 
 #include <OpenImageIO/imagebuf.h>
@@ -23,7 +25,9 @@ namespace toucan
     class FFmpegRead : public std::enable_shared_from_this<FFmpegRead>
     {
     public:
-        FFmpegRead(const std::filesystem::path&);
+        FFmpegRead(
+            const std::filesystem::path&,
+            const MemoryReference& = {});
 
         virtual ~FFmpegRead();
 
@@ -37,11 +41,25 @@ namespace toucan
         OIIO::ImageBuf _read();
 
         std::filesystem::path _path;
+        MemoryReference _memoryReference;
         OIIO::ImageSpec _spec;
         OTIO_NS::TimeRange _timeRange;
         OTIO_NS::RationalTime _currentTime;
 
+        struct AVIOBufferData
+        {
+            AVIOBufferData();
+            AVIOBufferData(const uint8_t*, size_t size);
+
+            const uint8_t* data = nullptr;
+            size_t size = 0;
+            size_t offset = 0;
+        };
+        static int _avIOBufferRead(void* opaque, uint8_t* buf, int bufSize);
+        static int64_t _avIOBufferSeek(void* opaque, int64_t offset, int whence);
+
         AVFormatContext* _avFormatContext = nullptr;
+        AVIOBufferData _avIOBufferData;
         uint8_t* _avIOContextBuffer = nullptr;
         AVIOContext* _avIOContext = nullptr;
         AVRational _avSpeed = { 24, 1 };

lib/toucan/ImageGraph.cpp

@@ -9,6 +9,7 @@
 #include "TimeWarp.h"
 #include "Util.h"
 
+#include <opentimelineio/clip.h>
 #include <opentimelineio/externalReference.h>
 #include <opentimelineio/gap.h>
 #include <opentimelineio/generatorReference.h>
@@ -24,27 +25,28 @@ namespace toucan
 
     ImageGraph::ImageGraph(
         const std::filesystem::path& path,
-        const std::shared_ptr<Timeline>& timeline,
+        const std::shared_ptr<TimelineWrapper>& timelineWrapper,
         const ImageGraphOptions& options) :
         _path(path),
-        _timeline(timeline),
-        _timeRange(timeline->getTimeRange()),
+        _timelineWrapper(timelineWrapper),
+        _timeRange(timelineWrapper->getTimeRange()),
         _options(options)
     {
         _loadCache.setMax(10);
 
         // Get the image size from the first video clip.
-        for (auto track : _timeline->otio()->find_children<OTIO_NS::Track>())
+        for (auto track : _timelineWrapper->getTimeline()->find_children<OTIO_NS::Track>())
         {
             if (OTIO_NS::Track::Kind::video == track->kind())
             {
                 for (auto clip : track->find_clips())
                 {
                     if (auto externalRef = dynamic_cast<OTIO_NS::ExternalReference*>(clip->media_reference()))
                     {
-                        const std::filesystem::path path = _timeline->getMediaPath(externalRef->target_url());
-                        const OIIO::ImageBuf buf(path.string());
-                        const auto& spec = buf.spec();
+                        auto read = std::make_shared<ReadNode>(
+                            _timelineWrapper->getMediaPath(externalRef->target_url()),
+                            _timelineWrapper->getMemoryReference(externalRef->target_url()));
+                        const auto& spec = read->getSpec();
                         if (spec.width > 0)
                         {
                             _imageSize.x = spec.width;
@@ -54,14 +56,16 @@ namespace toucan
                     }
                     else if (auto sequenceRef = dynamic_cast<OTIO_NS::ImageSequenceReference*>(clip->media_reference()))
                     {
-                        const std::filesystem::path path = getSequenceFrame(
-                            _timeline->getMediaPath(sequenceRef->target_url_base()),
+                        auto read = std::make_shared<SequenceReadNode>(
+                            _timelineWrapper->getMediaPath(sequenceRef->target_url_base()),
                             sequenceRef->name_prefix(),
+                            sequenceRef->name_suffix(),
                             sequenceRef->start_frame(),
+                            sequenceRef->frame_step(),
+                            sequenceRef->rate(),
                             sequenceRef->frame_zero_padding(),
-                            sequenceRef->name_suffix());
-                        const OIIO::ImageBuf buf(path.string());
-                        const auto& spec = buf.spec();
+                            _timelineWrapper->getMemoryReferences());
+                        const auto& spec = read->getSpec();
                         if (spec.width > 0)
                         {
                             _imageSize.x = spec.width;
@@ -102,7 +106,7 @@ namespace toucan
         std::shared_ptr<IImageNode> node = host->createNode("toucan:Fill", metaData);
 
         // Loop over the tracks.
-        auto stack = _timeline->otio()->tracks();
+        auto stack = _timelineWrapper->getTimeline()->tracks();
         for (const auto& i : stack->children())
         {
             if (auto track = OTIO_NS::dynamic_retainer_cast<OTIO_NS::Track>(i))
@@ -294,8 +298,9 @@ namespace toucan
                 std::shared_ptr<ReadNode> read;
                 if (!_loadCache.get(externalRef, read))
                 {
-                    const std::filesystem::path path = _timeline->getMediaPath(externalRef->target_url());
-                    read = std::make_shared<ReadNode>(path);
+                    read = std::make_shared<ReadNode>(
+                        _timelineWrapper->getMediaPath(externalRef->target_url()),
+                        _timelineWrapper->getMemoryReference(externalRef->target_url()));
                     _loadCache.add(externalRef, read);
                 }
                 out = read;
@@ -312,15 +317,15 @@ namespace toucan
             }
             else if (auto sequenceRef = dynamic_cast<OTIO_NS::ImageSequenceReference*>(clip->media_reference()))
             {
-                const std::filesystem::path path = _timeline->getMediaPath(sequenceRef->target_url_base());
                 auto read = std::make_shared<SequenceReadNode>(
-                    path,
+                    _timelineWrapper->getMediaPath(sequenceRef->target_url_base()),
                     sequenceRef->name_prefix(),
                     sequenceRef->name_suffix(),
                     sequenceRef->start_frame(),
                     sequenceRef->frame_step(),
                     sequenceRef->rate(),
-                    sequenceRef->frame_zero_padding());
+                    sequenceRef->frame_zero_padding(),
+                    _timelineWrapper->getMemoryReferences());
                 out = read;
             }
             else if (auto generatorRef = dynamic_cast<OTIO_NS::GeneratorReference*>(clip->media_reference()))

lib/toucan/ImageGraph.h

@@ -5,10 +5,11 @@
 
 #include <toucan/ImageNode.h>
 #include <toucan/MessageLog.h>
-#include <toucan/Timeline.h>
+#include <toucan/TimelineWrapper.h>
 
 #include <dtk/core/LRUCache.h>
 
+#include <opentimelineio/mediaReference.h>
 #include <opentimelineio/track.h>
 #include <opentimelineio/transition.h>
 
@@ -31,7 +32,7 @@ namespace toucan
     public:
         ImageGraph(
             const std::filesystem::path&,
-            const std::shared_ptr<Timeline>&,
+            const std::shared_ptr<TimelineWrapper>&,
             const ImageGraphOptions& = ImageGraphOptions());
 
         ~ImageGraph();
@@ -62,7 +63,7 @@ namespace toucan
             const std::shared_ptr<IImageNode>&);
 
         std::filesystem::path _path;
-        std::shared_ptr<Timeline> _timeline;
+        std::shared_ptr<TimelineWrapper> _timelineWrapper;
         OTIO_NS::TimeRange _timeRange;
         ImageGraphOptions _options;
         IMATH_NAMESPACE::V2i _imageSize = IMATH_NAMESPACE::V2i(0, 0);