implement layer level LENGTH override to support AUTO for all producers

TomKaltz · TomKaltz · commit 686f853b3fd2 · 2025-06-25T23:44:24.000-04:00
diff --git a/scratch.txt b/scratch.txt
@@ -0,0 +1,3 @@
+length for infinite time producers....so that you can set length for a looping ffmpeg file or decklink etc
+and it will be respected for autoplay.  We would like to introduce this for any producer
+ without breaking any current functionality.
diff --git a/src/core/producer/layer.cpp b/src/core/producer/layer.cpp
@@ -40,6 +40,8 @@ struct layer::impl
 
     bool auto_play_ = false;
     bool paused_    = false;
+    std::optional<uint32_t> foreground_length_override_;
+    std::optional<uint32_t> background_length_override_;
 
   public:
     impl(const core::video_format_desc format_desc)
@@ -55,6 +57,20 @@ struct layer::impl
     {
         background_ = std::move(producer);
         auto_play_  = auto_play;
+        background_length_override_.reset(); // Clear any previous length override
+
+        if (auto_play_ && foreground_ == frame_producer::empty()) {
+            play();
+        } else if (preview_producer) {
+            preview(true);
+        }
+    }
+
+    void load(spl::shared_ptr<frame_producer> producer, bool preview_producer, bool auto_play, std::optional<uint32_t> length)
+    {
+        background_ = std::move(producer);
+        auto_play_  = auto_play;
+        background_length_override_ = length;
 
         if (auto_play_ && foreground_ == frame_producer::empty()) {
             play();
@@ -90,6 +106,8 @@ struct layer::impl
 
             foreground_ = std::move(background_);
             background_ = frame_producer::empty();
+            foreground_length_override_ = background_length_override_;
+            background_length_override_.reset();
 
             auto_play_ = false;
         }
@@ -115,7 +133,8 @@ struct layer::impl
                 auto auto_play_delta = background_->auto_play_delta();
                 if (auto_play_delta) {
                     auto time     = static_cast<std::int64_t>(foreground_->frame_number());
-                    auto duration = static_cast<std::int64_t>(foreground_->nb_frames());
+                    auto duration = foreground_length_override_ ? static_cast<std::int64_t>(*foreground_length_override_) 
+                                                             : static_cast<std::int64_t>(foreground_->nb_frames());
                     frames_left   = duration - time - *auto_play_delta;
                     if (frames_left < 1 && field != video_field::b) {
                         play();
@@ -179,6 +198,10 @@ void layer::load(spl::shared_ptr<frame_producer> frame_producer, bool preview, b
 {
     return impl_->load(std::move(frame_producer), preview, auto_play);
 }
+void layer::load(spl::shared_ptr<frame_producer> frame_producer, bool preview, bool auto_play, std::optional<uint32_t> length)
+{
+    return impl_->load(std::move(frame_producer), preview, auto_play, length);
+}
 void       layer::play() { impl_->play(); }
 void       layer::preview() { impl_->preview(false); }
 void       layer::pause() { impl_->pause(); }
diff --git a/src/core/producer/layer.h b/src/core/producer/layer.h
@@ -44,6 +44,7 @@ class layer final
     void swap(layer& other);
 
     void load(spl::shared_ptr<frame_producer> producer, bool preview, bool auto_play = false);
+    void load(spl::shared_ptr<frame_producer> producer, bool preview, bool auto_play, std::optional<uint32_t> length);
     void play();
     void preview();
     void pause();
diff --git a/src/core/producer/stage.cpp b/src/core/producer/stage.cpp
@@ -286,6 +286,11 @@ struct stage::impl : public std::enable_shared_from_this<impl>
         return executor_.begin_invoke([=] { get_layer(index).load(producer, preview, auto_play); });
     }
 
+    std::future<void> load(int index, const spl::shared_ptr<frame_producer>& producer, bool preview, bool auto_play, std::optional<uint32_t> length)
+    {
+        return executor_.begin_invoke([=] { get_layer(index).load(producer, preview, auto_play, length); });
+    }
+
     std::future<void> preview(int index)
     {
         return executor_.begin_invoke([=] { get_layer(index).preview(); });
@@ -457,6 +462,10 @@ std::future<void> stage::load(int index, const spl::shared_ptr<frame_producer>&
 {
     return impl_->load(index, producer, preview, auto_play);
 }
+std::future<void> stage::load(int index, const spl::shared_ptr<frame_producer>& producer, bool preview, bool auto_play, std::optional<uint32_t> length)
+{
+    return impl_->load(index, producer, preview, auto_play, length);
+}
 std::future<void> stage::preview(int index) { return impl_->preview(index); }
 std::future<void> stage::pause(int index) { return impl_->pause(index); }
 std::future<void> stage::resume(int index) { return impl_->resume(index); }
@@ -545,7 +554,12 @@ std::future<frame_transform> stage_delayed::get_current_transform(int index)
 std::future<void>
 stage_delayed::load(int index, const spl::shared_ptr<frame_producer>& producer, bool preview, bool auto_play)
 {
-    return executor_.begin_invoke([=]() { return stage_->load(index, producer, preview, auto_play).get(); });
+    return executor_.begin_invoke([=] { return stage_->load(index, producer, preview, auto_play); });
+}
+std::future<void>
+stage_delayed::load(int index, const spl::shared_ptr<frame_producer>& producer, bool preview, bool auto_play, std::optional<uint32_t> length)
+{
+    return executor_.begin_invoke([=] { return stage_->load(index, producer, preview, auto_play, length); });
 }
 std::future<void> stage_delayed::preview(int index)
 {
diff --git a/src/core/producer/stage.h b/src/core/producer/stage.h
@@ -37,6 +37,7 @@
 #include <mutex>
 #include <tuple>
 #include <vector>
+#include <optional>
 
 namespace caspar::diagnostics {
 class graph;
@@ -82,6 +83,8 @@ class stage_base
     virtual std::future<frame_transform> get_current_transform(int index)                                          = 0;
     virtual std::future<void>
     load(int index, const spl::shared_ptr<frame_producer>& producer, bool preview = false, bool auto_play = false) = 0;
+    virtual std::future<void>
+    load(int index, const spl::shared_ptr<frame_producer>& producer, bool preview, bool auto_play, std::optional<uint32_t> length) = 0;
     virtual std::future<void>         preview(int index)                                                           = 0;
     virtual std::future<void>         pause(int index)                                                             = 0;
     virtual std::future<void>         resume(int index)                                                            = 0;
@@ -132,6 +135,7 @@ class stage final : public stage_base
                                       const spl::shared_ptr<frame_producer>& producer,
                                       bool                                   preview   = false,
                                       bool                                   auto_play = false) override;
+    std::future<void>            load(int index, const spl::shared_ptr<frame_producer>& producer, bool preview, bool auto_play, std::optional<uint32_t> length) override;
     std::future<void>            preview(int index) override;
     std::future<void>            pause(int index) override;
     std::future<void>            resume(int index) override;
@@ -188,6 +192,7 @@ class stage_delayed final : public stage_base
                                       const spl::shared_ptr<frame_producer>& producer,
                                       bool                                   preview   = false,
                                       bool                                   auto_play = false) override;
+    std::future<void>            load(int index, const spl::shared_ptr<frame_producer>& producer, bool preview, bool auto_play, std::optional<uint32_t> length) override;
     std::future<void>            preview(int index) override;
     std::future<void>            pause(int index) override;
     std::future<void>            resume(int index) override;
diff --git a/src/protocol/amcp/AMCPCommandsImpl.cpp b/src/protocol/amcp/AMCPCommandsImpl.cpp
@@ -308,9 +308,16 @@ std::wstring loadbg_command(command_context& ctx)
             transition_producer = create_transition_producer(new_producer, transitionInfo);
         }
 
+        // Check for LENGTH parameter for infinite time producers
+        auto length_param = get_param(L"LENGTH", ctx.parameters, std::optional<uint32_t>{});
+        
         // TODO - we should pass the format into load(), so that we can catch it having changed since the producer was
         // initialised
-        ctx.channel.stage->load(ctx.layer_index(), transition_producer, false, auto_play); // TODO: LOOP
+        if (length_param) {
+            ctx.channel.stage->load(ctx.layer_index(), transition_producer, false, auto_play, length_param);
+        } else {
+            ctx.channel.stage->load(ctx.layer_index(), transition_producer, false, auto_play); // TODO: LOOP
+        }
     } catch (file_not_found&) {
         if (contains_param(L"CLEAR_ON_404", ctx.parameters)) {
             ctx.channel.stage->load(
@@ -337,7 +344,14 @@ std::wstring load_command(command_context& ctx)
                 get_producer_dependencies(ctx.channel.raw_channel, ctx), ctx.parameters);
             auto transition_producer = create_transition_producer(new_producer, transition_info{});
 
-            ctx.channel.stage->load(ctx.layer_index(), transition_producer, true);
+            // Check for LENGTH parameter for infinite time producers
+            auto length_param = get_param(L"LENGTH", ctx.parameters, std::optional<uint32_t>{});
+            
+            if (length_param) {
+                ctx.channel.stage->load(ctx.layer_index(), transition_producer, true, false, length_param);
+            } else {
+                ctx.channel.stage->load(ctx.layer_index(), transition_producer, true);
+            }
         } catch (file_not_found&) {
             if (contains_param(L"CLEAR_ON_404", ctx.parameters)) {
                 ctx.channel.stage->load(

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+length for infinite time producers....so that you can set length for a looping ffmpeg file or decklink etc`
	`2`	`+and it will be respected for autoplay. We would like to introduce this for any producer`
	`3`	`+ without breaking any current functionality.`
Original file line number	Diff line number	Diff line change
`@@ -286,6 +286,11 @@ struct stage::impl : public std::enable_shared_from_this<impl>`
`286`	`286`	`return executor_.begin_invoke([=] { get_layer(index).load(producer, preview, auto_play); });`
`287`	`287`	`}`
`288`	`288`
	`289`	`+ std::future<void> load(int index, const spl::shared_ptr<frame_producer>& producer, bool preview, bool auto_play, std::optional<uint32_t> length)`
	`290`	`+ {`
	`291`	`+ return executor_.begin_invoke([=] { get_layer(index).load(producer, preview, auto_play, length); });`
	`292`	`+ }`
	`293`	`+`
`289`	`294`	`std::future<void> preview(int index)`
`290`	`295`	`{`
`291`	`296`	`return executor_.begin_invoke([=] { get_layer(index).preview(); });`
`@@ -457,6 +462,10 @@ std::future<void> stage::load(int index, const spl::shared_ptr<frame_producer>&`
`457`	`462`	`{`
`458`	`463`	`return impl_->load(index, producer, preview, auto_play);`
`459`	`464`	`}`
	`465`	`+std::future<void> stage::load(int index, const spl::shared_ptr<frame_producer>& producer, bool preview, bool auto_play, std::optional<uint32_t> length)`
	`466`	`+{`
	`467`	`+ return impl_->load(index, producer, preview, auto_play, length);`
	`468`	`+}`
`460`	`469`	`std::future<void> stage::preview(int index) { return impl_->preview(index); }`
`461`	`470`	`std::future<void> stage::pause(int index) { return impl_->pause(index); }`
`462`	`471`	`std::future<void> stage::resume(int index) { return impl_->resume(index); }`
`@@ -545,7 +554,12 @@ std::future<frame_transform> stage_delayed::get_current_transform(int index)`
`545`	`554`	`std::future<void>`
`546`	`555`	`stage_delayed::load(int index, const spl::shared_ptr<frame_producer>& producer, bool preview, bool auto_play)`
`547`	`556`	`{`
`548`		`- return executor_.begin_invoke([=]() { return stage_->load(index, producer, preview, auto_play).get(); });`
	`557`	`+ return executor_.begin_invoke([=] { return stage_->load(index, producer, preview, auto_play); });`
	`558`	`+}`
	`559`	`+std::future<void>`
	`560`	`+stage_delayed::load(int index, const spl::shared_ptr<frame_producer>& producer, bool preview, bool auto_play, std::optional<uint32_t> length)`
	`561`	`+{`
	`562`	`+ return executor_.begin_invoke([=] { return stage_->load(index, producer, preview, auto_play, length); });`
`549`	`563`	`}`
`550`	`564`	`std::future<void> stage_delayed::preview(int index)`
`551`	`565`	`{`