screenkit 0.0.0

data/lib/screenkit/exporter/intro.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+module ScreenKit
+  module Exporter
+    class Intro
+      include Shell
+      include Utils
+      extend SchemaValidator
+
+      def self.schema_path
+        ScreenKit.root_dir.join("screenkit/schemas/refs/intro.json")
+      end
+
+      # The intro scene configuration.
+      attr_reader :config
+
+      # The title text.
+      attr_reader :text
+
+      # The source path lookup instance.
+      attr_reader :source
+
+      # The log path.
+      attr_reader :log_path
+
+      def initialize(config:, text:, source:, log_path: nil)
+        self.class.validate!(config)
+        @config = config
+        @text = text
+        @source = source
+        @log_path = log_path
+      end
+
+      def logo_config
+        @logo_config ||= config[:logo]
+      end
+
+      def title_config
+        @title_config ||= config[:title]
+      end
+
+      def sound_config
+        return unless config[:sound]
+
+        @sound_config ||= case config[:sound]
+                          when String
+                            {path: config[:sound], volume: 1.0}
+                          else
+                            config[:sound]
+                          end
+      end
+
+      def logo_path
+        return unless logo_config
+
+        @logo_path ||= source.search(logo_config.fetch(:path))
+      end
+
+      def sound_path
+        return unless sound_config
+
+        @sound_path ||= source.search(sound_config.fetch(:path))
+      end
+
+      def background_path
+        return unless config[:background]
+        return if config[:background].start_with?("#")
+
+        @background_path ||= source.search(config[:background])
+      end
+
+      def font_path
+        return unless title_config&.[](:font_path)
+
+        @font_path ||= source.search(title_config[:font_path])
+      end
+
+      def export(path)
+        ffmpeg_params => {inputs:, filters:, maps:}
+
+        cmd = [
+          "ffmpeg",
+          *inputs,
+          "-filter_complex", filters,
+          *maps,
+          "-c:v", "libx264", "-crf", "0", "-pix_fmt", "yuv444p",
+          "-c:a", "flac", "-ac", "1", "-ar", "44100",
+          "-shortest",
+          "-t", config[:duration],
+          "-r", 24,
+          "-y",
+          path
+        ]
+
+        run_command(*cmd, log_path:)
+      end
+
+      private def ffmpeg_params
+        duration = config[:duration]
+        fade_in = config.fetch(:fade_in, 0.0)
+        fade_out = config.fetch(:fade_out, 0.5)
+        fade_out_start = duration - fade_out - 0.1
+
+        # Build filter chain
+        inputs = []
+        filters = []
+        stream_index = 0
+
+        # Background layer
+        if background_path&.file?
+          if video_file?(background_path)
+            # Ensure video is 24fps
+            extname = background_path.extname
+            optimized_path = background_path.sub_ext("_24fps#{extname}")
+
+            if (-0.02..0.02).cover?(fps(background_path))
+              optimized_path = background_path
+            end
+
+            unless optimized_path.file?
+              Video.new(input_path: background_path).export(optimized_path)
+            end
+
+            # Video background
+            video_duration = duration(optimized_path)
+
+            # Calculate how many loops we need
+            loops_needed = (duration / video_duration).ceil
+
+            inputs += [
+              "-stream_loop", (loops_needed - 1).to_s,
+              "-i", optimized_path
+            ]
+
+            # Scale, crop, then trim to exact duration needed
+            filters << "[#{stream_index}:v]scale=1920:1080:" \
+                       "force_original_aspect_ratio=increase:flags=lanczos," \
+                       "crop=1920:1080," \
+                       "trim=end=#{duration}," \
+                       "setpts=PTS-STARTPTS[bg]"
+          else
+            inputs += ["-loop", "1", "-t", duration, "-i", background_path]
+            filters << "[#{stream_index}:v]scale=1920:1080:" \
+                       "force_original_aspect_ratio=increase:flags=lanczos," \
+                       "crop=1920:1080,setpts=PTS-STARTPTS[bg]"
+          end
+        else
+          background = config.fetch(:background, "black")
+          inputs += [
+            "-f", "lavfi", "-i",
+            "color=c=#{background}:s=1920x1080:d=#{duration}"
+          ]
+          filters << "[#{stream_index}:v]setpts=PTS-STARTPTS[bg]"
+        end
+        stream_index += 1
+
+        current_layer = "bg"
+
+        # Logo layer (if present)
+        if logo_path
+          logo_width = logo_config.fetch(:width, 350)
+          logo_x = logo_config.fetch(:x, "center")
+          logo_y = logo_config.fetch(:y, "center")
+          overlay_x = logo_x == "center" ? "(W-w)/2" : logo_x
+          overlay_y = logo_y == "center" ? "(H-h)/2" : logo_y
+
+          inputs += ["-loop", "1", "-i", logo_path]
+          filters << "[#{stream_index}:v]scale=#{logo_width}:" \
+                     "-1:flags=lanczos[logo]"
+          filters << "[#{current_layer}][logo]overlay=#{overlay_x}:" \
+                     "#{overlay_y}[with_logo]"
+          current_layer = "with_logo"
+          stream_index += 1
+        end
+
+        # Title layer (if present)
+        if title_config
+          title_x = title_config.fetch(:x, "center")
+          title_y = title_config.fetch(:y, "center")
+          title_size = title_config.fetch(:size, 72)
+          title_color = title_config.fetch(:color, "white")
+
+          # Calculate max width based on x offset
+          max_width = if title_x == "center"
+                        1720 # 1920 - (2 * 100)
+                      else
+                        1920 - (2 * title_x.to_i)
+                      end
+
+          # Rough estimate characters per line based on font size
+          avg_char_width = title_size * 0.7
+          max_chars_per_line = (max_width / avg_char_width).floor
+
+          # Auto-wrap text
+          wrapped_text = wrap_text(text, max_chars_per_line)
+
+          # Convert position to drawtext coordinates
+          drawtext_x = title_x == "center" ? "(w-text_w)/2" : title_x
+          drawtext_y = title_y == "center" ? "(h-text_h)/2" : title_y
+
+          # Center align text when x is centered
+          text_align = title_x == "center" ? ":text_align=center" : ""
+
+          # Escape special characters in text
+          wrapped_text = wrapped_text.gsub("'", "'\\\\\\''").gsub(":", "\\:")
+
+          filters << "[#{current_layer}]drawtext=text='#{wrapped_text}':" \
+                     "fontfile=#{font_path}:fontsize=#{title_size}:" \
+                     "fontcolor=#{title_color}:x=#{drawtext_x}:" \
+                     "y=#{drawtext_y}#{text_align}[with_title]"
+          current_layer = "with_title"
+        end
+
+        # Apply fades to final video layer
+        # Use black for fade color when background is an image file
+        fade_color = background_path&.file? ? "black" : background
+        filters << "[#{current_layer}]fade=t=in:st=0:d=#{fade_in}:" \
+                   "c=#{fade_color},fade=t=out:st=#{fade_out_start}:" \
+                   "d=#{fade_out}:c=#{fade_color},setpts=PTS-STARTPTS[fade]"
+
+        # Audio (always generate, silent if no sound configured)
+        if sound_path
+          inputs += ["-i", sound_path]
+          sound_volume = sound_config.fetch(:volume, 1.0)
+          filters << "[#{stream_index}:a]apad,atrim=end=#{duration}," \
+                     "aresample=async=1,volume=#{sound_volume}[a]"
+        else
+          # Generate silent audio track
+          filters << "anullsrc=r=44100:cl=mono,atrim=end=#{duration}[a]"
+        end
+
+        maps = ["-map", "[fade]", "-map", "[a]"]
+
+        {inputs:, filters: filters.join(";"), maps:}
+      end
+
+      def wrap_text(text, max_chars_per_line)
+        return text if text.lines.size > 1
+
+        words = text.strip.split(/\s+/)
+        breaks = []
+        current_line = []
+
+        words.each do |word|
+          line_size_candidate = current_line.join(" ").length + word.length + 1
+
+          if line_size_candidate <= max_chars_per_line
+            current_line << word
+          else
+            breaks << current_line.join(" ")
+            current_line = [word]
+          end
+        end
+
+        breaks << current_line.join(" ") unless current_line.empty?
+
+        breaks.join("\n")
+      end
+    end
+  end
+end

data/lib/screenkit/exporter/outro.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module ScreenKit
+  module Exporter
+    class Outro
+      include Shell
+      include Utils
+      extend SchemaValidator
+
+      def self.schema_path
+        ScreenKit.root_dir.join("screenkit/schemas/refs/outro.json")
+      end
+
+      # The outro scene configuration.
+      attr_reader :config
+
+      # The source path lookup instance.
+      attr_reader :source
+
+      # The log path.
+      attr_reader :log_path
+
+      def initialize(config:, source:, log_path: nil)
+        self.class.validate!(config)
+        @config = config
+        @source = source
+        @log_path = log_path
+      end
+
+      def logo_config
+        @logo_config ||= config.fetch(:logo)
+      end
+
+      def sound_config
+        return unless config[:sound]
+
+        @sound_config ||= case config[:sound]
+                          when String
+                            {path: config[:sound], volume: 1.0}
+                          else
+                            config.fetch(:sound)
+                          end
+      end
+
+      def logo_path
+        @logo_path ||= source.search(logo_config.fetch(:path))
+      end
+
+      def sound_path
+        return unless sound_config
+
+        @sound_path ||= source.search(sound_config.fetch(:path))
+      end
+
+      def background_path
+        return unless config[:background]
+        return if config[:background].to_s.start_with?("#")
+
+        @background_path ||= source.search(config[:background])
+      end
+
+      def export(path)
+        ffmpeg_params => {inputs:, filters:, maps:}
+
+        cmd = [
+          "ffmpeg",
+          *inputs,
+          "-sws_flags", "lanczos+accurate_rnd+full_chroma_int",
+          "-filter_complex", filters,
+          *maps,
+          "-c:v", "libx264", "-crf", "0", "-pix_fmt", "yuv444p",
+          "-c:a", "flac", "-ac", "1", "-ar", "44100",
+          "-shortest",
+          "-t", config[:duration],
+          "-r", 24,
+          "-y",
+          path
+        ]
+
+        run_command(*cmd, log_path:)
+      end
+
+      private def ffmpeg_params
+        duration = config[:duration]
+        logo_delay = 0.5
+        fade_in = config.fetch(:fade_in, 0.5)
+        fade_out = config.fetch(:fade_out, 0.5)
+        fade_out_start = duration - fade_out - 0.1
+
+        # Build filter chain
+        inputs = []
+        filters = []
+        stream_index = 0
+
+        # Background layer
+        if background_path&.file?
+          if video_file?(background_path)
+            # Video background
+            video_duration = duration(background_path)
+
+            # Calculate how many loops we need
+            loops_needed = (duration / video_duration).ceil
+
+            inputs += [
+              "-stream_loop", (loops_needed - 1).to_s, "-i",
+              background_path
+            ]
+
+            # Scale, crop, then trim to exact duration needed
+            filters << "[#{stream_index}:v]scale=1920:1080:" \
+                       "force_original_aspect_ratio=increase:flags=lanczos," \
+                       "crop=1920:1080," \
+                       "trim=end=#{duration}," \
+                       "setpts=PTS-STARTPTS[bg]"
+          else
+            # Image background
+            inputs += ["-loop", "1", "-t", duration, "-i", background_path]
+            filters << "[#{stream_index}:v]scale=1920:1080:" \
+                       "force_original_aspect_ratio=increase:flags=lanczos," \
+                       "crop=1920:1080,setpts=PTS-STARTPTS[bg]"
+          end
+        else
+          # Color background
+          background = config.fetch(:background, "black")
+          inputs += [
+            "-f", "lavfi", "-i",
+            "color=c=#{background}:s=1920x1080:d=#{duration}"
+          ]
+          filters << "[#{stream_index}:v]setpts=PTS-STARTPTS[bg]"
+        end
+        stream_index += 1
+
+        current_layer = "bg"
+
+        # Logo layer
+        logo_width = logo_config.fetch(:width, 350)
+        logo_x = logo_config.fetch(:x, "center")
+        logo_y = logo_config.fetch(:y, "center")
+        overlay_x = logo_x == "center" ? "(W-w)/2" : logo_x
+        overlay_y = logo_y == "center" ? "(H-h)/2" : logo_y
+
+        inputs += ["-loop", "1", "-i", logo_path]
+        filters << "[#{stream_index}:v]scale=#{logo_width}:" \
+                   "-1:flags=lanczos[logo]"
+        filters << "[#{current_layer}][logo]overlay=#{overlay_x}:" \
+                   "#{overlay_y}[with_logo]"
+        current_layer = "with_logo"
+        stream_index += 1
+
+        # Apply fades to final video layer
+        # Use black for fade color when background is a file
+        fade_color = if background_path&.file?
+                       "black"
+                     else
+                       config.fetch(
+                         :background, "black"
+                       )
+                     end
+        filters <<
+          "[#{current_layer}]fade=t=in:st=#{logo_delay}:d=#{fade_in}:" \
+          "c=#{fade_color},fade=t=out:st=#{fade_out_start}:" \
+          "d=#{fade_out}:c=#{fade_color},setpts=PTS-STARTPTS[fade]"
+
+        # Audio (always generate, silent if no sound configured)
+        if sound_path
+          inputs += ["-i", sound_path]
+          sound_volume = sound_config.fetch(:volume, 1.0)
+          filters << "[#{stream_index}:a]adelay=#{(logo_delay * 1000).to_i}|" \
+                     "#{(logo_delay * 1000).to_i}," \
+                     "apad,atrim=end=#{duration}," \
+                     "aresample=async=1,volume=#{sound_volume}[a]"
+        else
+          # Generate silent audio track
+          filters << "anullsrc=r=44100:cl=mono,atrim=end=#{duration}[a]"
+        end
+
+        maps = ["-map", "[fade]", "-map", "[a]"]
+
+        {inputs:, filters: filters.join(";"), maps:}
+      end
+    end
+  end
+end

data/lib/screenkit/exporter/segment.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module ScreenKit
+  module Exporter
+    class Segment
+      include Shell
+      include Utils
+
+      # The path to the content file for this segment.
+      # @return [Pathname]
+      attr_reader :content_path
+
+      # The episode exporter this segment belongs to.
+      # @return [ScreenKit::Exporter::Episode]
+      attr_reader :episode
+
+      # The prefix number of the segment file.
+      attr_reader :prefix
+
+      def initialize(content_path:, episode:)
+        @prefix = content_path.basename.to_s[/^(\d+)/, 1]
+        @content_path = content_path
+        @episode = episode
+      end
+
+      def script_path
+        @script_path ||= episode.root_dir.join("scripts", "#{prefix}.txt")
+      end
+
+      def video_path
+        @video_path ||= episode.output_dir.join("videos", "#{prefix}.mp4")
+      end
+
+      def callouts_path
+        @callouts_path ||= episode.root_dir.join("callouts/#{prefix}.yml")
+      end
+
+      def segment_path
+        @segment_path ||= episode.output_dir.join("segments", "#{prefix}.mp4")
+      end
+
+      def voiceover_path
+        return episode.mute_sound_path unless episode.tts?
+
+        dir = episode.root_dir.join("voiceovers")
+        dir.glob("#{prefix}.{#{ContentType.audio.join(',')}}").first ||
+          dir.join("#{prefix}.mp3")
+      end
+
+      def output_voiceover_path
+        episode.output_dir.join("voiceovers").join("#{prefix}.flac")
+      end
+
+      def callouts
+        @callouts ||= if callouts_path.file?
+                        YAML.load_file(callouts_path, symbolize_names: true)
+                      else
+                        []
+                      end
+      end
+
+      def export_video(log_path:)
+        return if video_path.file? && !episode.options.overwrite
+
+        log_path = format(log_path.to_s, prefix:) if log_path
+
+        case content_path.extname.downcase.gsub(/^\./, "")
+        when *ContentType.video
+          Exporter::Video
+            .new(input_path: content_path, log_path:)
+            .export(video_path)
+        when *ContentType.image
+          Exporter::Image
+            .new(image_path: content_path, log_path:)
+            .export(video_path)
+        when *ContentType.demotape
+          Exporter::Demotape
+            .new(demotape_path: content_path, log_path:)
+            .export(video_path)
+        else
+          raise "Unsupported content type: #{content_path.extname}"
+        end
+      end
+
+      def crossfade_duration
+        episode.scenes.fetch(:segment).fetch(:crossfade_duration, 0.5)
+      end
+
+      def merge_audio_and_video(log_path:)
+        # Get video duration
+        video_duration = duration(video_path)
+
+        # Get audio duration
+        audio_duration = duration(output_voiceover_path)
+
+        # Calculate the content duration and extend by crossfade duration
+        content_duration = [video_duration, audio_duration].max
+        final_duration = content_duration + crossfade_duration
+
+        # # Calculate padding needed for audio (content + silence for crossfade)
+        audio_pad_samples = ((final_duration - audio_duration) * 44_100).to_i
+
+        # Calculate video padding (content + cloned frame for crossfade)
+        video_pad_duration = final_duration - video_duration
+
+        # The raw video and voiceover
+        inputs = ["-i", video_path, "-i", output_voiceover_path]
+
+        filters = [
+          "[0:v]tpad=stop_mode=clone:stop_duration=#{video_pad_duration}[v0]"
+        ]
+
+        audio_mix_inputs = ["[1:a]"]
+        animation_duration = 0.2
+
+        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 = 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:,
+            index:,
+            starts_at:,
+            ends_at:,
+            x:,
+            y:,
+            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}]"
+        end
+
+        # Mix all audio streams (voiceover + all sounds)
+        filters << "#{audio_mix_inputs.join}amix=inputs=" \
+                   "#{audio_mix_inputs.size}:duration=longest:normalize=0" \
+                   "[mixed_audio]"
+        filters << "[mixed_audio]aresample=async=1,apad=pad_len=" \
+                   "#{audio_pad_samples}[a]"
+
+        filter_complex = filters.join(";")
+
+        cmd = [
+          "ffmpeg",
+          *inputs,
+          "-filter_complex",
+          filter_complex,
+          "-map", "[v#{callouts.size}]",
+          "-map", "[a]",
+          "-t", final_duration,
+          "-r", 24,
+          "-c:a", "flac", "-ac", "1", "-ar", "44100",
+          "-c:v", "libx264", "-crf", "0", "-pix_fmt", "yuv444p",
+          "-y",
+          segment_path
+        ]
+
+        run_command(*cmd, log_path: create_log_path(log_path, __method__))
+      end
+
+      def export_voiceover(log_path:)
+        create_voiceover(log_path: create_log_path(log_path))
+        normalize_voiceover(
+          log_path: create_log_path(log_path, :normalize)
+        )
+      end
+
+      def normalize_voiceover(log_path:)
+        run_command "ffmpeg-normalize",
+                    voiceover_path,
+                    "-f",
+                    "-o", output_voiceover_path,
+                    "-nt", "ebu",
+                    "-t", "-18",
+                    "-c:a", "flac", "-ac", "1", "-ar", "44100",
+                    log_path:
+      end
+
+      def create_voiceover(log_path:)
+        return if voiceover_path&.file? && !episode.options.overwrite
+        return unless script_path.file?
+        return unless episode.tts?
+
+        FileUtils.mkdir_p(voiceover_path.dirname)
+
+        episode.tts_engine.generate(
+          text: script_path.read,
+          output_path: voiceover_path,
+          log_path:
+        )
+      end
+
+      def create_log_path(path, tag = nil)
+        return path unless path
+
+        path = path.sub_ext("-#{tag.to_s.tr('_', '-')}.txt") if tag
+
+        format(path.to_s, prefix:) if path
+      end
+    end
+  end
+end