screenkit 0.0.1 → 0.0.3

data/lib/screenkit/callout/styles/file_copy.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ScreenKit
+  class Callout
+    module Styles
+      class FileCopy < Base
+        def self.schema_path
+          ScreenKit.root_dir
+                   .join("screenkit/schemas/callout_styles/file_copy.json")
+        end
+
+        def initialize(source:, **kwargs)
+          self.class.validate!(kwargs)
+          super
+        end
+
+        def render
+          ext = File.extname(options[:file_path])
+          FileUtils.mkdir_p(File.dirname(output_path))
+          FileUtils.cp source.search(options[:file_path]),
+                       output_path.sub_ext(ext)
+        end
+      end
+    end
+  end
+end

data/lib/screenkit/callout/styles/inline_block.rb

@@ -6,30 +6,27 @@ module ScreenKit
   class Callout
     module Styles
       class InlineBlock < Base
-        extend SchemaValidator
-
         attr_reader :background_color, :text_style, :body,
-                    :output_path, :padding, :text, :width, :source
+                    :padding, :text, :width
 
         def self.schema_path
           ScreenKit.root_dir
-                   .join("screenkit/schemas/callouts/inline_block.json")
+                   .join("screenkit/schemas/callout_styles/inline_block.json")
         end
 
-        def initialize(source:, **kwargs) #  rubocop:disable Lint/MissingSuper
+        def initialize(source:, **kwargs)
           self.class.validate!(kwargs)
-
-          @source = source
+          super
 
           # Set default values
-          kwargs = hi_res({
+          self.options = hi_res({
             text_style: {size: 50, color: "#ffffff"}.merge(text_style || {}),
             width: 600,
             padding: [10, 10, 10, 10],
             background_color: "#000000"
           }.merge(kwargs))
 
-          kwargs.each do |key, value|
+          options.each do |key, value|
             value = case key
                     when :padding
                       Spacing.new(value)

data/lib/screenkit/callout/styles/{default.rb → shadow_block.rb}

@@ -5,20 +5,18 @@ require "mini_magick"
 module ScreenKit
   class Callout
     module Styles
-      class Default < Base
-        extend SchemaValidator
-
-        attr_reader :background_color, :body, :body_style,
-                    :output_path, :padding, :shadow,
-                    :title, :title_style, :width, :source
+      class ShadowBlock < Base
+        attr_reader :background_color, :body, :body_style, :padding, :shadow,
+                    :title, :title_style, :width
 
         def self.schema_path
-          ScreenKit.root_dir.join("screenkit/schemas/callouts/default.json")
+          ScreenKit.root_dir
+                   .join("screenkit/schemas/callout_styles/shadow_block.json")
         end
 
-        def initialize(source:, **kwargs) #  rubocop:disable Lint/MissingSuper
+        def initialize(source:, **kwargs)
           self.class.validate!(kwargs)
-          @source = source
+          super
 
           # Set default values
           kwargs[:shadow] = case kwargs[:shadow]
@@ -32,9 +30,9 @@ module ScreenKit
                               kwargs[:shadow]
                             end
 
-          kwargs = hi_res({width: 600}.merge(kwargs))
+          self.options = hi_res({width: 600}.merge(kwargs))
 
-          kwargs.each do |key, value|
+          options.each do |key, value|
             value = case key
                     when :body_style, :title_style
                       TextStyle.new(source:, **value)

data/lib/screenkit/callout.rb

@@ -32,7 +32,7 @@ module ScreenKit
                   :style_props, :style_class, :animation, :source, :log_path
 
     def self.schema_path
-      ScreenKit.root_dir.join("screenkit/schemas/refs/callout.json")
+      ScreenKit.root_dir.join("screenkit/schemas/refs/callout_style.json")
     end
 
     def initialize(

data/lib/screenkit/cli/episode.rb

@@ -24,8 +24,7 @@ module ScreenKit
         options[:episode_dir] = config.episode_dir.parent.join(dir)
 
         generator = Generators::Episode.new
-        generator.destination_root =
-          File.expand_path(File.dirname(options.config))
+        generator.destination_root = File.dirname(options.config)
         generator.options = options
         generator.invoke_all
       end
@@ -35,7 +34,7 @@ module ScreenKit
              type: :string,
              required: true,
              desc: "Directory of the episode to export"
-      option :voice_api_key,
+      option :tts_api_key,
              type: :string,
              desc: "API key for the voice synthesis service"
       option :overwrite,

data/lib/screenkit/cli/root.rb

@@ -9,7 +9,7 @@ module ScreenKit
       desc "new PATH", "Create a new project"
       def new(path)
         generator = Generators::Project.new
-        generator.destination_root = File.expand_path(path)
+        generator.destination_root = path
         generator.options = options
         generator.invoke_all
       end

data/lib/screenkit/config/episode.rb

@@ -18,6 +18,12 @@ module ScreenKit
       # The watermark configuration.
       attr_reader :watermark
 
+      # The demotape configuration.
+      attr_reader :demotape
+
+      # The callout styles configuration.
+      attr_reader :callout_styles
+
       def self.schema_path
         @schema_path ||=
           ScreenKit.root_dir.join("screenkit/schemas/episode.json")

data/lib/screenkit/config/project.rb

@@ -12,8 +12,8 @@ module ScreenKit
       # The output directory for exported files.
       attr_reader :output_dir
 
-      # Callout configurations
-      attr_reader :callouts
+      # Callout styles
+      attr_reader :callout_styles
 
       # Scene configurations
       attr_reader :scenes
@@ -27,6 +27,9 @@ module ScreenKit
       # The watermark configuration.
       attr_reader :watermark
 
+      # The demotape configuration.
+      attr_reader :demotape
+
       def self.schema_path
         @schema_path ||=
           ScreenKit.root_dir.join("screenkit/schemas/project.json")

data/lib/screenkit/exporter/demotape.rb

@@ -5,6 +5,10 @@ module ScreenKit
     class Demotape
       include Shell
 
+      DURATION_ATTRIBUTES = %w[
+        typing_speed loop_delay run_enter_delay run_sleep
+      ].freeze
+
       attr_reader :demotape_path, :log_path, :options
 
       def initialize(demotape_path:, options: {}, log_path: nil)
@@ -28,6 +32,10 @@ module ScreenKit
 
       def options_to_args(options)
         (options || {}).flat_map do |key, value|
+          if DURATION_ATTRIBUTES.include?(key.to_s)
+            value = Duration.parse(value)
+          end
+
           [key.to_s.tr("_", "-").prepend("--"), value]
         end
       end

data/lib/screenkit/exporter/episode.rb

@@ -37,12 +37,8 @@ module ScreenKit
         @logfile = Logfile.new(output_dir.join("logs"))
       end
 
-      def tts?
-        config.tts || project_config.tts
-      end
-
-      def tts_options
-        (config.tts || {}).merge(project_config.tts || {})
+      def tts_available?
+        tts_engines.any?(&:available?)
       end
 
       def demotape_options
@@ -50,9 +46,28 @@ module ScreenKit
       end
 
       def tts_engine
-        @tts_engine ||= TTS.const_get(
-          tts_options[:engine].camelize
-        ).new(**tts_options.except(:engine))
+        tts_engines.find(&:available?)
+      end
+
+      def tts_engines
+        @tts_engines ||= begin
+          project_tts = if project_config.tts.is_a?(Hash)
+                          [project_config.tts]
+                        else
+                          Array(project_config.tts)
+                        end
+
+          episode_tts = if config.tts.is_a?(Hash)
+                          [config.tts]
+                        else
+                          Array(config.tts)
+                        end
+
+          (episode_tts + project_tts).map do |opts|
+            TTS.const_get(opts[:engine].camelize)
+               .new(**opts.except(:engine), api_key: options.tts_api_key)
+          end
+        end
       end
 
       # Logs a message to the shell with a specific category.
@@ -97,7 +112,7 @@ module ScreenKit
 
       def export_callouts
         callouts = filtered_segments.flat_map do |segment|
-          segment.callouts.map { {prefix: segment.prefix, callouts: it} }
+          segment.callouts.map { {prefix: segment.prefix, callout: it} }
         end
 
         elapsed = ParallelProcessor.new(
@@ -106,15 +121,16 @@ module ScreenKit
           message: "Exporting callouts (%{progress}/%{count})"
         ).run do |item, index|
           log_path = logfile.create(item[:prefix], :callout, index)
-          type = item[:callouts].fetch(:type).to_sym
-          callout_style = project_config
-                          .callouts
+          type = item[:callout].fetch(:type).to_sym
+
+          callout_style = callout_styles
                           .fetch(type)
-                          .merge(item[:callouts].except(:starts_at, :duration))
+                          .merge(item[:callout])
           callout_path = output_dir
                          .join("callouts", "#{item[:prefix]}-#{index}.png")
           Callout.new(
-            source:, **callout_style,
+            source:,
+            **callout_style,
             output_path: callout_path,
             log_path:
           ).render
@@ -187,7 +203,7 @@ module ScreenKit
         ]
 
         backtrack_adjustment = 1.0 / backtrack.volume
-        backtrack_fade_volume = if tts?
+        backtrack_fade_volume = if tts_available?
                                   0.15 * backtrack_adjustment
                                 else
                                   1.0
@@ -401,7 +417,7 @@ module ScreenKit
           dir: shell.set_color(relative_path(root_dir), :blue)
         )
 
-        unless tts?
+        unless tts_available?
           log(
             :info,
             shell.set_color("Voiceover is currently disabled", :red),
@@ -528,6 +544,10 @@ module ScreenKit
         end
       end
 
+      def callout_styles
+        (project_config.callout_styles || {}).merge(config.callout_styles || {})
+      end
+
       def output_video_path
         @output_video_path ||= output_dir.join("#{root_dir.basename}.mp4")
       end

data/lib/screenkit/exporter/segment.rb

@@ -40,7 +40,7 @@ module ScreenKit
       end
 
       def voiceover_path
-        return episode.mute_sound_path unless episode.tts?
+        return episode.mute_sound_path unless episode.tts_available?
 
         dir = episode.root_dir.join("voiceovers")
         dir.glob("#{prefix}.{#{ContentType.audio.join(',')}}").first ||
@@ -117,79 +117,19 @@ module ScreenKit
 
         audio_mix_inputs = ["[1:a]"]
         animation_duration = 0.2
+        current_input_index = 2 # Start after video (0) and voiceover (1)
 
         callouts.each_with_index do |callout, index|
-          type = callout[:type].to_sym
-          callout_config = episode.project_config.callouts[type]
-          in_sound = Sound.new(input: callout_config[:in_transition][:sound],
-                               source: episode.source)
-          out_sound = Sound.new(input: callout_config[:out_transition][:sound],
-                                source: episode.source)
-
-          starts_at = callout[:starts_at]
-          max_duration = [content_duration - 0.2, 0].max
-          duration = Duration.parse(callout[:duration])
-                             .clamp(0, max_duration)
-                             .round(half: :down)
-          ends_at = starts_at + duration
-          callout_image_path = episode.output_dir.join("callouts",
-                                                       "#{prefix}-#{index}.png")
-          image_width, image_height = image_size(callout_image_path)
-
-          x, y = calculate_position(
-            anchor: Anchor.new(callout_config[:anchor]),
-            margin: Spacing.new(callout_config[:margin] || 0),
-            width: image_width,
-            height: image_height
-          )
-
-          inputs += [
-            "-loop", "1",
-            "-t", duration,
-            "-i", callout_image_path,
-
-            # Add sound for transition in
-            "-i", in_sound.path,
-
-            # Add sound for transition out
-            "-i", out_sound.path
-          ]
-
-          input_stream = "v#{index}"
-          output_stream = "v#{index + 1}"
-          callout_index = 2 + (index * 3)
-
-          animation_filters = AnimationFilters.new(
-            content_duration:,
-            callout_index:,
-            input_stream:,
-            output_stream:,
+          current_input_index = process_callout(
+            callout:,
             index:,
-            starts_at:,
-            ends_at:,
-            x:,
-            y:,
+            content_duration:,
             animation_duration:,
-            image_width:,
-            image_height:
-          ).send(callout_config[:animation])
-
-          filters.concat(animation_filters[:video])
-
-          # Delay and mix callout sounds
-          in_index = callout_index + 1
-          out_index = callout_index + 2
-
-          filters << "[#{in_index}:a]volume=#{in_sound.volume}," \
-                     "adelay=#{(starts_at * 1000).to_i}|" \
-                     "#{(starts_at * 1000).to_i}[in_#{index}]"
-          filters << "[#{out_index}:a]volume=#{out_sound.volume}," \
-                     "adelay=#{(animation_filters[:out_start] * 1000).to_i}|" \
-                     "#{(animation_filters[:out_start] * 1000).to_i}" \
-                     "[out_#{index}]"
-
-          audio_mix_inputs << "[in_#{index}]"
-          audio_mix_inputs << "[out_#{index}]"
+            inputs:,
+            filters:,
+            audio_mix_inputs:,
+            current_input_index:
+          )
         end
 
         # Mix all audio streams (voiceover + all sounds)
@@ -240,7 +180,7 @@ module ScreenKit
       def create_voiceover(log_path:)
         return if voiceover_path&.file? && !episode.options.overwrite
         return unless script_path.file?
-        return unless episode.tts?
+        return unless episode.tts_available?
 
         FileUtils.mkdir_p(voiceover_path.dirname)
 
@@ -258,6 +198,257 @@ module ScreenKit
 
         format(path.to_s, prefix:) if path
       end
+
+      def process_callout(
+        callout:,
+        index:,
+        content_duration:,
+        animation_duration:,
+        inputs:,
+        filters:,
+        audio_mix_inputs:,
+        current_input_index:
+      )
+        type = callout[:type].to_sym
+        callout_config = episode.callout_styles[type]
+        in_sound = Sound.new(input: callout_config[:in_transition][:sound],
+                             source: episode.source)
+        out_sound = Sound.new(input: callout_config[:out_transition][:sound],
+                              source: episode.source)
+
+        starts_at = TimeFormatter.parse(callout[:starts_at])
+        max_duration = [content_duration - 0.2, 0].max
+        duration = Duration.parse(callout[:duration])
+                           .clamp(0, max_duration)
+                           .round(half: :down)
+        ends_at = starts_at + duration
+        callout_duration = ends_at - starts_at
+
+        callout_path = find_callout_path(index)
+        video_callout = video_callout?(callout_path)
+        has_video_audio = has_audio?(callout_path)
+
+        callout_width, callout_height = image_size(callout_path)
+        x, y = calculate_callout_position(
+          video_callout:,
+          callout_config:,
+          callout_width:,
+          callout_height:
+        )
+
+        callout_index, current_input_index = add_callout_inputs(
+          inputs:,
+          current_input_index:,
+          callout_path:,
+          video_callout:,
+          has_video_audio:,
+          duration:
+        )
+
+        in_sound_index, out_sound_index, current_input_index =
+          add_transition_sound_inputs(
+            inputs:,
+            current_input_index:,
+            video_callout:,
+            in_sound:,
+            out_sound:
+          )
+
+        animation_filters = add_video_filters(
+          filters:,
+          index:,
+          callout_index:,
+          callout_config:,
+          video_callout:,
+          content_duration:,
+          starts_at:,
+          ends_at:,
+          x:,
+          y:,
+          animation_duration:,
+          callout_width:,
+          callout_height:
+        )
+
+        add_audio_filters(
+          filters:,
+          audio_mix_inputs:,
+          index:,
+          callout_index:,
+          video_callout:,
+          has_video_audio:,
+          starts_at:,
+          callout_duration:,
+          in_sound:,
+          out_sound:,
+          in_sound_index:,
+          out_sound_index:,
+          animation_filters:
+        )
+
+        current_input_index
+      end
+
+      def find_callout_path(index)
+        callout_path = episode.output_dir.join("callouts").glob(
+          "#{prefix}-#{index}.{png,#{ContentType.video.join(',')}}"
+        ).first
+
+        raise "Callout file not found for #{prefix}-#{index}" unless callout_path
+
+        callout_path
+      end
+
+      def video_callout?(callout_path)
+        ContentType.video.include?(callout_path.extname.delete_prefix("."))
+      end
+
+      def calculate_callout_position(
+        video_callout:,
+        callout_config:,
+        callout_width:,
+        callout_height:
+      )
+        # For video callouts, ignore anchor/margin and position at 0,0
+        # (assumes videos are already properly sized and positioned)
+        if video_callout
+          [0, 0]
+        else
+          calculate_position(
+            anchor: Anchor.new(callout_config[:anchor]),
+            margin: Spacing.new(callout_config[:margin] || 0),
+            width: callout_width,
+            height: callout_height
+          )
+        end
+      end
+
+      def add_callout_inputs(
+        inputs:,
+        current_input_index:,
+        callout_path:,
+        video_callout:,
+        has_video_audio:,
+        duration:
+      )
+        callout_index = current_input_index
+
+        if video_callout
+          # Don't use -t for videos, let them play naturally
+          inputs << "-i" << callout_path
+          current_input_index += 1
+
+          # Add mute audio if video has no audio
+          unless has_video_audio
+            inputs << "-t" << duration << "-i" << episode.mute_sound_path
+            current_input_index += 1
+          end
+        else
+          inputs << "-loop" << "1" << "-t" << duration << "-i" << callout_path
+          current_input_index += 1
+        end
+
+        [callout_index, current_input_index]
+      end
+
+      def add_transition_sound_inputs(
+        inputs:,
+        current_input_index:,
+        video_callout:,
+        in_sound:,
+        out_sound:
+      )
+        # Add transition sounds (only for non-video callouts)
+        return [nil, nil, current_input_index] if video_callout
+
+        in_sound_index = current_input_index
+        inputs << "-i" << in_sound.path
+        current_input_index += 1
+
+        out_sound_index = current_input_index
+        inputs << "-i" << out_sound.path
+        current_input_index += 1
+
+        [in_sound_index, out_sound_index, current_input_index]
+      end
+
+      def add_video_filters(
+        filters:,
+        index:,
+        callout_index:,
+        callout_config:,
+        video_callout:,
+        content_duration:,
+        starts_at:,
+        ends_at:,
+        x:,
+        y:,
+        animation_duration:,
+        callout_width:,
+        callout_height:
+      )
+        input_stream = "v#{index}"
+        output_stream = "v#{index + 1}"
+        animation_method = video_callout ? :video : callout_config[:animation]
+
+        animation_filters = AnimationFilters.new(
+          content_duration:,
+          callout_index:,
+          input_stream:,
+          output_stream:,
+          index:,
+          starts_at:,
+          ends_at:,
+          x:,
+          y:,
+          animation_duration:,
+          image_width: callout_width,
+          image_height: callout_height
+        ).send(animation_method)
+
+        filters.concat(animation_filters[:video])
+
+        animation_filters
+      end
+
+      def add_audio_filters(
+        filters:,
+        audio_mix_inputs:,
+        index:,
+        callout_index:,
+        video_callout:,
+        has_video_audio:,
+        starts_at:,
+        callout_duration:,
+        in_sound:,
+        out_sound:,
+        in_sound_index:,
+        out_sound_index:,
+        animation_filters:
+      )
+        # Mix video audio if present
+        if video_callout && has_video_audio
+          filters <<
+            "[#{callout_index}:a]atrim=end=#{callout_duration}," \
+            "asetpts=PTS-STARTPTS,adelay=#{(starts_at * 1000).to_i}|" \
+            "#{(starts_at * 1000).to_i}[video_audio_#{index}]"
+          audio_mix_inputs << "[video_audio_#{index}]"
+        end
+
+        # For non-video callouts, add transition sounds
+        return if video_callout
+
+        filters << "[#{in_sound_index}:a]volume=#{in_sound.volume}," \
+                   "adelay=#{(starts_at * 1000).to_i}|" \
+                   "#{(starts_at * 1000).to_i}[in_#{index}]"
+        filters << "[#{out_sound_index}:a]volume=#{out_sound.volume}," \
+                   "adelay=#{(animation_filters[:out_start] * 1000).to_i}|" \
+                   "#{(animation_filters[:out_start] * 1000).to_i}" \
+                   "[out_#{index}]"
+
+        audio_mix_inputs << "[in_#{index}]"
+        audio_mix_inputs << "[out_#{index}]"
+      end
     end
   end
 end

data/lib/screenkit/generators/episode/callouts/001.yml

@@ -0,0 +1,12 @@
+---
+- type: default
+  title: ScreenKit
+  body: https://github.com/fnando/screenkit
+  duration: 5s
+  starts_at: 00:00:02
+  width: 800
+
+- type: inline_block
+  text: gem install screenkit
+  duration: 5s
+  starts_at: 00:00:02